Erlang 21 - 2. Logging

2 लॉगिंग




erlang

2 लॉगिंग

Erlang / OTP 21.0 Logger माध्यम से लॉगिंग के लिए एक मानक एपीआई प्रदान करता है, जो कर्नेल अनुप्रयोग का हिस्सा है। लकड़हारे के पास लॉग इवेंट जारी करने के लिए एपीआई होता है, और एक अनुकूलन योग्य बैकेंड होता है जहां लॉग हैंडलर, फिल्टर और फॉर्मेटर्स को प्लग इन किया जा सकता है।

डिफ़ॉल्ट रूप से, कर्नेल अनुप्रयोग सिस्टम प्रारंभ में एक लॉग हैंडलर स्थापित करता है। इस हैंडलर को default नाम दिया गया default । यह Erlang रनटाइम सिस्टम, मानक व्यवहार और विभिन्न Erlang / OTP अनुप्रयोगों द्वारा निर्मित मानक लॉग ईवेंट प्राप्त करता है और संसाधित करता है। लॉग ईवेंट डिफ़ॉल्ट रूप से टर्मिनल पर लिखे गए हैं।

आप सिस्टम को कॉन्फ़िगर भी कर सकते हैं ताकि डिफॉल्ट हैंडलर एक ईवेंट को लॉग फ़ाइल में या एक डिस्क के सेट को disk_log जरिए disk_log

कॉन्फ़िगरेशन द्वारा, आप डिफ़ॉल्ट हैंडलर को संशोधित या अक्षम भी कर सकते हैं, इसे कस्टम हैंडलर द्वारा प्रतिस्थापित कर सकते हैं और अतिरिक्त हैंडलर स्थापित कर सकते हैं।

ध्यान दें

चूंकि लॉगर एरलांग / ओटीपी 21.0 में नया है, इसलिए हम इस रिलीज के बाद पैच में एपीआई लॉगर एपीआई और कार्यक्षमता में बदलाव लाने का अधिकार सुरक्षित रखते हैं। ये परिवर्तन प्रारंभिक संस्करण के साथ पीछे की ओर संगत हो भी सकते हैं और नहीं भी।

२.१ अवलोकन करें

लॉग इवेंट में लॉग स्तर , लॉग किया जाने वाला संदेश और मेटाडेटा शामिल हैं

लकड़हारा एपीआई से आगे की घटनाओं का समर्थन करता है, पहले प्राथमिक फिल्टर के एक सेट के माध्यम से, फिर प्रत्येक लॉग हैंडलर से जुड़े माध्यमिक फिल्टर के एक सेट के माध्यम से। द्वितीयक फिल्टर निम्नलिखित हैंडलर फिल्टर में हैं

प्रत्येक फ़िल्टर सेट में लॉग स्तर की जांच होती है , जिसके बाद शून्य या अधिक फ़िल्टर फ़ंक्शन होते हैं

निम्नलिखित आंकड़ा लकड़हारा का एक वैचारिक अवलोकन दिखाता है। आंकड़ा दो लॉग हैंडलर दिखाता है, लेकिन किसी भी संख्या में हैंडलर स्थापित किए जा सकते हैं।

चित्र 2.1: वैचारिक अवलोकन

लॉग स्तर परमाणुओं के रूप में व्यक्त किए जाते हैं। आंतरिक रूप से लकड़हारे में, परमाणुओं को पूर्णांक मानों में मैप किया जाता है, और यदि लॉग स्तर की पूर्णांक मान वर्तमान में कॉन्फ़िगर किए गए लॉग स्तर से कम या बराबर है, तो लॉग ईवेंट लॉग स्तर की जाँच करता है। यही है, चेक पास हो जाता है अगर घटना कॉन्फ़िगर स्तर से समान या अधिक गंभीर है। सभी लॉग स्तरों की सूची और विवरण के लिए अनुभाग Log Level देखें।

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

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

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

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

संचालकों को अनुक्रम में कहा जाता है, और आदेश को परिभाषित नहीं किया जाता है।

2.2 लकड़हारा एपीआई

लॉगिंग के लिए एपीआई में macros का एक सेट होता macros , और फॉर्म logger:Level/1,2,3 पर कार्यों का एक सेट होता है logger:Level/1,2,3 , जो logger:log(Level,Arg1[,Arg2[,Arg3]]) लिए सभी शॉर्टकट हैं logger:log(Level,Arg1[,Arg2[,Arg3]])

मैक्रोज़ और निर्यात किए गए फ़ंक्शंस का उपयोग करने के बीच का अंतर यह है कि मैक्रोज़ मेटाडेटा में स्थान (प्रवर्तक) जानकारी जोड़ते हैं, और केस स्टेटमेंट में लकड़हारा कॉल लपेटकर आलसी मूल्यांकन करता है, इसलिए यह केवल मूल्यांकन किया जाता है कि क्या घटना का लॉग स्तर गुजरता है प्राथमिक लॉग स्तर की जाँच करें।

छांटने का स्तर

लॉग स्तर एक घटना की गंभीरता को इंगित करता है। Syslog प्रोटोकॉल, RFC 5424 , आठ लॉग स्तर निर्दिष्ट किए जा सकते हैं। निम्न तालिका नाम (परमाणु), पूर्णांक मान और विवरण द्वारा सभी संभव लॉग स्तरों को सूचीबद्ध करती है:

स्तर पूर्णांक विवरण
आपातकालीन 0 सिस्टम अनुपयोगी है
चेतावनी 1 तुरंत कार्रवाई की जानी चाहिए
महत्वपूर्ण 2 गंभीर स्थिति
त्रुटि 3 त्रुटि की स्थिति
चेतावनी 4 चेतावनी की स्थिति
नोटिस 5 सामान्य लेकिन महत्वपूर्ण स्थिति
जानकारी 6 सूचना संदेश
डिबग 7 डिबग-स्तरीय संदेश

तालिका 2.1: लॉग स्तर

ध्यान दें कि पूर्णांक मान केवल लकड़हारे में आंतरिक रूप से उपयोग किया जाता है। एपीआई में, आपको हमेशा परमाणु का उपयोग करना चाहिए। दो लॉग स्तरों की गंभीरता की तुलना करने के लिए, logger:compare_levels/2 उपयोग करें logger:compare_levels/2

लॉग संदेश

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

उदाहरण, प्रारूप स्ट्रिंग और तर्क:

logger:error("The file does not exist: ~ts",[Filename])

उदाहरण, स्ट्रिंग:

logger:notice("Something strange happened!")

रिपोर्ट कॉलबैक के साथ उदाहरण, रिपोर्ट और मेटाडेटा:

logger:debug(#{got => connection_request, id => Id, state => State},
             #{report_cb => fun(R) -> {"~p",[R]} end})

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

मेटाडाटा

मेटाडेटा में लॉग संदेश के साथ संबद्ध अतिरिक्त डेटा होता है। लकड़हारा डिफ़ॉल्ट रूप से कुछ मेटाडेटा फ़ील्ड सम्मिलित करता है, और क्लाइंट दो अलग-अलग तरीकों से कस्टम मेटाडेटा जोड़ सकता है:

प्रक्रिया मेटाडेटा सेट करें

प्रक्रिया मेटाडेटा को logger:set_process_metadata/1 साथ सेट और अद्यतन किया जाता है logger:set_process_metadata/1 और logger:update_process metadata/1 , क्रमशः। यह मेटाडेटा उस प्रक्रिया पर लागू होता है जिस पर ये कॉल किए जाते हैं, और लकड़हारा उस प्रक्रिया पर जारी किए गए सभी लॉग इवेंट में मेटाडेटा जोड़ता है।

मेटाडेटा को किसी विशिष्ट लॉग ईवेंट में जोड़ें

एक विशिष्ट लॉग ईवेंट से जुड़ी मेटाडेटा को लॉग मैक्रो या लॉगर एपीआई फ़ंक्शन के अंतिम पैरामीटर के रूप में दिया जाता है जब ईवेंट जारी किया जाता है। उदाहरण के लिए:

?LOG_ERROR("Connection closed",#{context => server})

logger:metadata() का विवरण देखें logger:metadata() प्रकार के बारे में जानकारी के लिए कि कौन सी डिफ़ॉल्ट कुंजी लकड़हारा आवेषण, और कैसे अलग मेटाडाटा नक्शे विलय कर रहे हैं।

2.3 फ़िल्टर

फिल्टर प्राथमिक हो सकते हैं, या एक विशिष्ट हैंडलर से जुड़े हो सकते हैं। लकड़हारा प्राथमिक फिल्टर को पहले कॉल करता है, और यदि वे सभी पास होते हैं, तो यह प्रत्येक हैंडलर के लिए हैंडलर फिल्टर को कॉल करता है। लकड़हारा हैंडलर कॉलबैक को केवल तभी कॉल करता है जब प्रश्न में हैंडलर से जुड़े सभी फ़िल्टर भी गुजरते हैं।

एक फिल्टर के रूप में परिभाषित किया गया है:

{FilterFun, Extra}

जहां FilterFun arity 2 का एक फंक्शन है, और FilterFun कोई भी शब्द है। फ़िल्टर लागू करते समय, लॉगर फ़ंक्शन को लॉग इवेंट के साथ पहले तर्क के रूप में कहता है, और Extra के मूल्य को दूसरे तर्क के रूप में। logger:filter() देखें logger:filter() प्रकार परिभाषा के लिए logger:filter()

फ़िल्टर फ़ंक्शन stop , ignore या (संभवतः संशोधित) लॉग ईवेंट को वापस कर सकता है।

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

यदि लॉग ईवेंट लौटाया जाता है, तो अगला फ़िल्टर फ़ंक्शन पहले तर्क के रूप में दिए गए मान के साथ कहा जाता है। अर्थात्, यदि कोई फ़िल्टर फ़ंक्शन लॉग ईवेंट को संशोधित करता है, तो अगला फ़िल्टर फ़ंक्शन संशोधित ईवेंट प्राप्त करता है। अंतिम फ़िल्टर फ़ंक्शन से लौटाया गया मूल्य वह मूल्य है जो हैंडलर कॉलबैक प्राप्त करता है।

यदि फ़िल्टर फ़ंक्शन वापस लौटता है, तो इसका मतलब है कि यह लॉग ईवेंट को नहीं पहचानता है, और इस तरह ईवेंट की नियति को तय करने के लिए अन्य फ़िल्टर पर छोड़ देता है।

कॉन्फ़िगरेशन विकल्प filter_default व्यवहार को निर्दिष्ट करता है यदि सभी फ़िल्टर फ़ंक्शंस ignore , या यदि कोई फ़िल्टर मौजूद नहीं है। filter_default डिफ़ॉल्ट रूप से log करने के लिए सेट है, जिसका अर्थ है कि यदि सभी मौजूदा फ़िल्टर किसी लॉग ईवेंट को अनदेखा करते हैं, तो लॉगर ईवेंट को हैंडलर कॉलबैक में फॉरवर्ड कर देता है। अगर filter_default को stop करने के लिए सेट किया गया है, तो लकड़हारा ऐसी घटनाओं को stop देता है।

प्राथमिक फ़िल्टर को logger:add_primary_filter/2 साथ जोड़ा जाता है logger:add_primary_filter/2 और logger:remove_primary_filter/1 साथ logger:remove_primary_filter/1 दिया logger:remove_primary_filter/1 । उन्हें कर्नेल कॉन्फ़िगरेशन पैरामीटर logger माध्यम से सिस्टम स्टार्ट पर भी जोड़ा जा सकता है।

हैंडलर फिल्टर को logger:add_handler_filter/3 साथ जोड़ा जाता है logger:add_handler_filter/3 और logger:remove_handler_filter/2 साथ logger:remove_handler_filter/2 दिया logger:remove_handler_filter/2 logger:add_handler/3 साथ हैंडलर जोड़ते समय उन्हें सीधे कॉन्फ़िगरेशन में भी निर्दिष्ट किया जा सकता है logger:add_handler/3 या कर्नेल कॉन्फ़िगरेशन पैरामीटर logger:add_handler/3 माध्यम से।

वर्तमान में सिस्टम में कौन से फ़िल्टर स्थापित हैं, यह देखने के लिए, logger:get_config/0 उपयोग करें logger:get_config/0 , या logger:get_primary_config/0 और logger:get_handler_config/1 । फ़िल्टर को उस क्रम में सूचीबद्ध किया जाता है जिस पर उन्हें लागू किया जाता है, अर्थात, सूची में पहला फ़िल्टर पहले लागू किया जाता है, और इसी तरह।

सुविधा के लिए, निम्न अंतर्निहित फ़िल्टर मौजूद हैं:

logger_filters:domain/2

Metadata में एक domain फ़ील्ड के आधार पर लॉग इवेंट को फ़िल्टर करने का एक तरीका प्रदान करता है।

logger_filters:level/2

लॉग स्तर के आधार पर लॉग इवेंट को फ़िल्टर करने का एक तरीका प्रदान करता है।

logger_filters:progress/2

supervisor और application_controller से प्रगति रिपोर्ट को रोक देता है या अनुमति देता है।

logger_filters:remote_gl/2

स्टॉप या लॉग इवेंट को एक प्रक्रिया से उत्पन्न होने की अनुमति देता है जो एक दूरस्थ नोड पर अपने समूह के नेता है।

२.४ हैंडलर

एक हैंडलर को कम से कम निम्नलिखित कॉलबैक फ़ंक्शन को निर्यात करने वाले मॉड्यूल के रूप में परिभाषित किया गया है:

log(LogEvent, Config) -> void()

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

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

अनिवार्य कॉलबैक फ़ंक्शन log/2 , एक हैंडलर मॉड्यूल वैकल्पिक कॉलबैक फ़ंक्शन adding_handler/1 , adding_handler/1 changing_config/2 और adding_handler/1 को निर्यात कर सकता है। इन फ़ंक्शन के बारे में अधिक जानकारी के लिए लकड़हारा (3) मैनुअल पेज में अनुभाग Handler Callback Functions देखें।

निम्नलिखित अंतर्निहित हैंडलर मौजूद हैं:

logger_std_h

यह OTP द्वारा उपयोग किया जाने वाला डिफ़ॉल्ट हैंडलर है। कई उदाहरण शुरू किए जा सकते हैं, और प्रत्येक उदाहरण किसी दिए गए गंतव्य, टर्मिनल या फ़ाइल में लॉग ईवेंट लिखेंगे।

logger_disk_log_h

यह हैंडलर logger_std_h तरह अधिक व्यवहार करता है, सिवाय इसके कि यह अपने गंतव्य के रूप में disk_log का उपयोग करता है।

error_logger

यह हैंडलर केवल पश्चगामी संगतता के लिए प्रदान किया जाता है। यह डिफ़ॉल्ट रूप से शुरू नहीं हुआ है, लेकिन एक error_logger ईवेंट हैंडलर को पहली बार error_logger:add_report_handler/1,2 साथ जोड़े जाने पर स्वचालित रूप से शुरू हो जाएगा।

STDLIB और SASL में पुराने error_logger ईवेंट हैंडलर अभी भी मौजूद हैं, लेकिन वे Erlang / OTP 21.0 या बाद में नहीं जोड़े गए हैं।

2.5 प्रारूपक

हैंडलर के गंतव्य पर प्रिंट करने से पहले, किसी लॉग इवेंट के अंतिम स्वरूपण को करने के लिए हैंडलर कार्यान्वयन द्वारा एक फॉर्मेटर का उपयोग किया जा सकता है। हैंडलर कॉलबैक को हैंडलर कॉन्फ़िगरेशन के भाग के रूप में HModule:log/2 जानकारी प्राप्त होती है, जिसे HModule:log/2 के दूसरे तर्क के रूप में पारित किया जाता है।

फ़ॉर्मेटर की जानकारी में एक फॉर्मेट मॉड्यूल, FModule और उसके कॉन्फ़िगरेशन, FConfig FModule को निम्नलिखित फ़ंक्शन का निर्यात करना चाहिए, जिसे हैंडलर द्वारा बुलाया जा सकता है:

format(LogEvent,FConfig) -> FormattedLogEntry

हैंडलर के लिए फ़ॉर्मेटर की जानकारी हैंडलर को जोड़ने पर इसके कॉन्फ़िगरेशन के एक भाग के रूप में सेट की जाती है। इसे logger:set_handler_config(HandlerId,formatter,{FModule,FConfig}) साथ रनटाइम के दौरान भी बदला जा सकता है logger:set_handler_config(HandlerId,formatter,{FModule,FConfig}) , जो वर्तमान फॉर्मेट जानकारी को अधिलेखित करता है, या logger:update_formatter_config/2,3 , जो केवल फॉर्मेट कॉन्फ़िगरेशन को संशोधित करता है।

यदि check_config(FConfig) मॉड्यूल वैकल्पिक कॉलबैक फ़ंक्शन check_config(FConfig) निर्यात करता है, तो फ़ॉर्मेटर जानकारी की वैधता को सत्यापित करने के लिए, फ़ॉर्मेटर जानकारी सेट या संशोधित होने पर, लकड़हारा इस फ़ंक्शन को कॉल करता है।

यदि हैंडलर के लिए कोई logger_formatter जानकारी निर्दिष्ट नहीं है, तो लकड़हारा डिफ़ॉल्ट रूप में logger_formatter का उपयोग करता है। इस मॉड्यूल के बारे में अधिक जानकारी के लिए logger_formatter(3) मैनुअल पेज देखें।

2.6 विन्यास

सिस्टम प्रारंभ में, लकड़हारा को कर्नेल कॉन्फ़िगरेशन मापदंडों के माध्यम से कॉन्फ़िगर किया गया है। लकड़हारा पर लागू होने वाले मापदंडों को अनुभाग Kernel Configuration Parameters में वर्णित किया गया है। उदाहरण अनुभाग Configuration Examples में पाए जाते हैं।

रनटाइम के दौरान, लकड़हारा विन्यास एपीआई कार्यों के माध्यम से बदल दिया जाता है। logger(3) मैनुअल पेज में अनुभाग Configuration API Functions देखें।

प्राथमिक लकड़हारा विन्यास

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

प्राथमिक लकड़हारा विन्यास निम्नलिखित कुंजी के साथ एक नक्शा है:

level = logger:level() | all | none | all | none

प्राथमिक लॉग स्तर को निर्दिष्ट करता है, अर्थात, लॉग इवेंट जो इस स्तर से समान या अधिक गंभीर होते हैं, प्राथमिक फ़िल्टर के लिए अग्रेषित किए जाते हैं। कम गंभीर लॉग ईवेंट तुरंत खारिज कर दिए जाते हैं।

संभावित लॉग स्तरों की सूची और विवरण के लिए अनुभाग Log Level देखें।

इस विकल्प का प्रारंभिक मान कर्नेल कॉन्फ़िगरेशन पैरामीटर logger_level द्वारा सेट किया गया है। इसे logger:set_primary_config(level,Level) साथ रनटाइम के दौरान बदल दिया जाता है logger:set_primary_config(level,Level)

info लिए चूक।

filters = [{FilterId,Filter}]

प्राथमिक फ़िल्टर निर्दिष्ट करता है।

इस विकल्प का प्रारंभिक मूल्य कर्नेल कॉन्फ़िगरेशन पैरामीटर logger द्वारा निर्धारित किया गया है। रनटाइम के दौरान, प्राथमिक फिल्टर को logger:add_primary_filter/2 साथ जोड़ा और हटा दिया जाता है logger:add_primary_filter/2 और logger:remove_primary_filter/1 , क्रमशः।

अधिक विस्तृत जानकारी के लिए अनुभाग Filters देखें।

चूक []

filter_default = log | stop

निर्दिष्ट करता है कि लॉग इवेंट में क्या होता है यदि सभी फ़िल्टर ignore , या यदि कोई फ़िल्टर मौजूद नहीं है।

यह विकल्प कैसे उपयोग किया जाता है, इसके बारे में अधिक जानकारी के लिए अनुभाग Filters देखें।

log करने के लिए चूक।

हैंडलर विन्यास

लकड़हारा एपीआई कार्य जो हैंडलर कॉन्फ़िगरेशन पर लागू होते हैं:

हैंडलर के लिए कॉन्फ़िगरेशन निम्न कुंजियों के साथ एक नक्शा है:

id = logger:handler_id()

स्वचालित रूप से लकड़हारा द्वारा डाला गया। मान उसी प्रकार है जैसे हैंडलर को जोड़ने के दौरान HandlerId निर्दिष्ट किया गया है, और इसे बदला नहीं जा सकता है।

module = module()

स्वचालित रूप से लकड़हारा द्वारा डाला गया। मूल्य उसी तरह है जैसे कि हैंडलर को जोड़ने के दौरान निर्दिष्ट Module , और इसे बदला नहीं जा सकता।

level = logger:level() | all | none | all | none

हैंडलर के लिए लॉग स्तर निर्दिष्ट करता है, अर्थात, लॉग इवेंट जो इस स्तर से समान या अधिक गंभीर होते हैं, उन्हें इस हैंडलर के लिए हैंडलर फ़िल्टर के लिए अग्रेषित किया जाता है।

संभावित लॉग स्तरों की सूची और विवरण के लिए अनुभाग Log Level देखें।

हैंडलर को जोड़ने पर लॉग स्तर निर्दिष्ट किया जाता है, या उदाहरण के लिए रनटाइम के दौरान परिवर्तित किया जाता है, logger:set_handler_config(HandlerId,formatter,{FModule,FConfig})

all लिए चूक।

filters = [{FilterId,Filter}]

हैंडलर फ़िल्टर निर्दिष्ट करता है।

हैंडलर फिल्टर को निर्दिष्ट किया जाता है जब हैंडलर जोड़ते हैं, या logger:add_handler_filter/3 साथ रनटाइम के दौरान जोड़ा या हटाया जाता है logger:add_handler_filter/3 और logger:remove_handler_filter/2 , क्रमशः।

अधिक विस्तृत जानकारी के लिए Filters देखें।

चूक []

filter_default = log | stop

निर्दिष्ट करता है कि लॉग इवेंट में क्या होता है यदि सभी फ़िल्टर ignore , या यदि कोई फ़िल्टर मौजूद नहीं है।

यह विकल्प कैसे उपयोग किया जाता है, इसके बारे में अधिक जानकारी के लिए अनुभाग Filters देखें।

log करने के लिए चूक।

formatter = {FormatterModule,FormatterConfig}

एक फ़ॉर्मेटर निर्दिष्ट करता है जिसे हैंडलर लॉग इवेंट शब्द को प्रिंट करने योग्य स्ट्रिंग में परिवर्तित करने के लिए उपयोग कर सकता है।

हैंडलर को जोड़ते समय फ़ॉर्मेटर की जानकारी निर्दिष्ट की जाती है। logger:update_formatter_config/2,3 साथ रनटाइम के दौरान logger:update_formatter_config/2,3 कॉन्फ़िगरेशन को बदला जा सकता है logger:update_formatter_config/2,3 , या पूर्ण फ़ॉर्मेट जानकारी के साथ ओवरराइट किया जा सकता है, उदाहरण के लिए, logger:set_handler_config(HandlerId,formatter,{FModule,FConfig})

अधिक विस्तृत जानकारी के लिए अनुभाग formatter देखें।

{logger_formatter,DefaultFormatterConfig} लिए डिफ़ॉल्ट। इस फ़ॉर्मेटर और इसके डिफ़ॉल्ट कॉन्फ़िगरेशन के बारे में जानकारी के लिए logger_formatter(3) मैनुअल पेज देखें।

config = term()

हैंडलर विशिष्ट कॉन्फ़िगरेशन, अर्थात कॉन्फ़िगरेशन डेटा एक विशिष्ट हैंडलर कार्यान्वयन से संबंधित है।

अंतर्निहित हैंडलर के लिए कॉन्फ़िगरेशन को logger_std_h(3) और logger_disk_log_h(3) मैनुअल पृष्ठों में वर्णित किया गया है।

ध्यान दें कि प्रत्येक हैंडलर को लॉग ईवेंट्स को अग्रेषित करने से पहले लेगर और level का पालन स्वयं लॉगर द्वारा किया जाता है, जबकि formatter और सभी हैंडलर विशिष्ट विकल्प हैंडलर कार्यान्वयन के लिए छोड़ दिए जाते हैं।

कर्नेल कॉन्फ़िगरेशन पैरामीटर

निम्न कर्नेल कॉन्फ़िगरेशन पैरामीटर लकड़हारे के लिए लागू होते हैं:

logger = [Config]

Logger लिए कॉन्फ़िगरेशन को निर्दिष्ट करता है, प्राथमिक लॉग स्तर को छोड़कर, जो logger_level साथ निर्दिष्ट है, और SASL Error Logging के साथ संगतता, जो logger_sasl_compatible साथ निर्दिष्ट है।

इस पैरामीटर के साथ, आप डिफ़ॉल्ट हैंडलर को संशोधित या अक्षम कर सकते हैं, कस्टम हैंडलर और प्राथमिक लकड़हारा फ़िल्टर जोड़ सकते हैं, और प्रति मॉड्यूल लॉग स्तर सेट कर सकते हैं।

Config निम्न में से कोई (शून्य या अधिक) है:

{handler, default, undefined}

डिफ़ॉल्ट हैंडलर को अक्षम करता है। यह एक अन्य एप्लिकेशन को अपने स्वयं के डिफ़ॉल्ट हैंडलर को जोड़ने की अनुमति देता है।

इस प्रकार की केवल एक प्रविष्टि की अनुमति है।

{handler, HandlerId, Module, HandlerConfig}

यदि HandlerId default , तो यह प्रविष्टि कॉल के बराबर डिफ़ॉल्ट हैंडलर को संशोधित करती है

set_handler_config/2,3

HandlerId अन्य सभी मूल्यों के लिए, यह प्रविष्टि कॉलिंग के बराबर एक नया हैंडलर जोड़ता है

logger:add_handler(HandlerId, Module, HandlerConfig)

इस प्रकार की एकाधिक प्रविष्टियों की अनुमति है।

{filters, FilterDefault, [Filter]}

निर्दिष्ट प्राथमिक फिल्टर जोड़ता है।

  • FilterDefault = log | stop
  • Filter = {FilterId, {FilterFun, FilterConfig}}

बुलाने के बराबर

logger:add_primary_filter/2

प्रत्येक Filter

FilterDefault व्यवहार को निर्दिष्ट करता है यदि सभी प्राथमिक फ़िल्टर ignore , तो अनुभाग Filters देखें।

इस प्रकार की केवल एक प्रविष्टि की अनुमति है।

{module_level, Level, [Module]}

दिए गए मॉड्यूल के लिए मॉड्यूल लॉग स्तर सेट करता है। बुलाने के बराबर

logger:set_module_level(Module, Level)

प्रत्येक Module

इस प्रकार की एकाधिक प्रविष्टियों की अनुमति है।

सिस्टम कॉन्फ़िगरेशन के लिए logger पैरामीटर का उपयोग करके Configuration Examples लिए अनुभाग Configuration Examples देखें।

logger_level = Level

प्राथमिक लॉग स्तर निर्दिष्ट करता है। इस पैरामीटर के बारे में अधिक जानकारी के लिए kernel(6) मैनुअल पेज देखें।

logger_sasl_compatible = true | false

SASL Error Logging के साथ लॉगर की संगतता निर्दिष्ट करता है। इस पैरामीटर के बारे में अधिक जानकारी के लिए kernel(6) मैनुअल पेज देखें।

विन्यास उदाहरण

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

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

Standard_io के बजाय फ़ाइल में प्रिंट करने के लिए डिफ़ॉल्ट हैंडलर को संशोधित करें:

[{kernel,
  [{logger,
    [{handler, default, logger_std_h,  % {handler, HandlerId, Module,
      #{config => #{type => {file,"log/erlang.log"}}}}  % Config}
    ]}]}].

प्रत्येक लॉग ईवेंट को एक पंक्ति के रूप में मुद्रित करने के लिए डिफ़ॉल्ट हैंडलर को संशोधित करें:

[{kernel,
  [{logger,
    [{handler, default, logger_std_h,
      #{formatter => {logger_formatter, #{single_line => true}}}}
    ]}]}].

प्रत्येक लॉग ईवेंट के लिए लॉगिंग प्रक्रिया के पृष्ठ को प्रिंट करने के लिए डिफ़ॉल्ट हैंडलर को संशोधित करें:

[{kernel,
  [{logger,
    [{handler, default, logger_std_h,
      #{formatter => {logger_formatter,
                        #{template => [time," ",pid," ",msg,"\n"]}}}}
    ]}]}].

डिफ़ॉल्ट हैंडलर को केवल "लॉग / erlang.log" के लिए त्रुटियों और अधिक गंभीर लॉग ईवेंट्स को प्रिंट करने के लिए संशोधित करें, और "लॉग / डीबग.लॉग" के लिए सभी लॉग इवेंट को प्रिंट करने के लिए एक और हैंडलर जोड़ें।

[{kernel,
  [{logger,
    [{handler, default, logger_std_h,
      #{level => error,
        config => #{type => {file, "log/erlang.log"}}}},
     {handler, info, logger_std_h,
      #{level => debug,
        config => #{type => {file, "log/debug.log"}}}}
    ]}]}].

2.7 Error_logger के साथ पीछे की संगतता

लकड़हारा निम्नलिखित तरीकों से error_logger के साथ पश्चगामी संगतता प्रदान करता है:

लॉगिंग के लिए एपीआई

error_logger API अभी भी मौजूद है, लेकिन इसका उपयोग केवल विरासत कोड द्वारा किया जाना चाहिए। इसे बाद के रिलीज़ में हटा दिया जाएगा।

error_logger:error_msg/1,2 error_logger:error_report/1,2 , error_logger:error_msg/1,2 , और चेतावनी और सूचना संदेशों के लिए संबंधित कार्य के लिए कॉल, सभी error_logger:error_msg/1,2 को लकड़हारा के रूप में भेजा जाता है logger:log(Level,Report,Metadata)

Level = error | warning | info Level = error | warning | info और फ़ंक्शन नाम से ली गई है। Report में वास्तविक लॉग संदेश होता है, और Metadata में अतिरिक्त जानकारी होती है जो कि लीगेसी error_logger ईवेंट हैंडलर के लिए बैकवर्ड संगत इवेंट बनाने के लिए उपयोग की जा सकती है, अनुभाग Legacy Event Handlers

आउटपुट स्वरूप

error_logger_tty_h और error_logger_file_h द्वारा निर्मित समान स्वरूप पर लॉग ईवेंट प्राप्त करने के लिए, डिफ़ॉल्ट पैरामीटर, logger_formatter उपयोग करें, कॉन्फ़िगरेशन पैरामीटर legacy_header सेट करें। यह कर्नेल द्वारा शुरू किए गए default हैंडलर का डिफ़ॉल्ट कॉन्फ़िगरेशन है।

OTP से लॉग इवेंट्स का डिफ़ॉल्ट स्वरूप

डिफ़ॉल्ट रूप से, OTP के भीतर होने वाली सभी लॉग ईवेंट, जो कि तथाकथित "एसएएसएल रिपोर्ट" को छोड़कर, पहले जैसी ही हैं।

एसएएसएल रिपोर्ट्स

एसएएसएल रिपोर्टों से हमारा मतलब है कि पर्यवेक्षक रिपोर्ट, क्रैश रिपोर्ट और प्रगति रिपोर्ट।

एर्लैंग / OTP 21.0 से पहले, ये रिपोर्ट केवल तभी लॉग की गई थी जब एसएएसएल एप्लिकेशन चल रहा था, और वे sasl_report_tty_h के स्वयं के ईवेंट हैंडलर sasl_report_tty_h और sasl_report_file_h को प्रिंट कर रहे थे।

इन लॉग इवेंट का गंतव्य SASL configuration parameters द्वारा कॉन्फ़िगर किया गया था।

विशिष्ट ईवेंट हैंडलर के कारण, आउटपुट स्वरूप अन्य लॉग ईवेंट से थोड़ा भिन्न होता है।

एर्लैंग / ओटीपी 21.0 के अनुसार, एसएएसएल रिपोर्ट की अवधारणा को हटा दिया जाता है, जिसका अर्थ है कि डिफ़ॉल्ट व्यवहार निम्नानुसार है:

  • पर्यवेक्षक रिपोर्ट, क्रैश रिपोर्ट और प्रगति रिपोर्ट अब एसएएसएल आवेदन से जुड़े नहीं हैं।
  • पर्यवेक्षक रिपोर्ट और क्रैश रिपोर्ट को error स्तर लॉग इवेंट के रूप में जारी किया जाता है, और कर्नेल द्वारा शुरू किए गए डिफ़ॉल्ट हैंडलर के माध्यम से लॉग किया जाता है।
  • प्रगति रिपोर्ट को info स्तर लॉग इवेंट के रूप में जारी किया जाता है, और चूंकि डिफ़ॉल्ट प्राथमिक लॉग स्तर notice , ये डिफ़ॉल्ट रूप से लॉग नहीं होते हैं। प्रगति रिपोर्ट के मुद्रण को सक्षम करने के लिए, primary log level को info सेट करें।
  • सभी लॉग इवेंट के लिए आउटपुट स्वरूप समान है।

यदि पुराना व्यवहार पसंद किया जाता है, तो कर्नेल कॉन्फ़िगरेशन पैरामीटर logger_sasl_compatible को true सेट किया जा सकता trueSASL configuration parameters को पहले की तरह इस्तेमाल किया जा सकता है, और एसएएसएल रिपोर्ट केवल तभी प्रिंट की जाएगी जब एसएएसएल एप्लिकेशन चल रहा है, दूसरे लॉग हैंडलर के माध्यम से sasl

सभी एसएएसएल रिपोर्टों में मेटाडेटा फ़ील्ड domain होता है जो [otp,sasl] सेट होता है। इस फ़ील्ड का उपयोग लॉग इवेंट्स को रोकने या अनुमति देने के लिए फ़िल्टर द्वारा किया जा सकता है।

पुराने SASL त्रुटि लॉगिंग कार्यक्षमता के बारे में अधिक जानकारी के लिए अनुभाग SASL User's Guide देखें।

विरासत घटना संचालकों

error_logger लिए लिखे गए ईवेंट हैंडलर का उपयोग करने के लिए, बस अपने ईवेंट हैंडलर को साथ जोड़ें

error_logger:add_report_handler/1,2.

यह स्वचालित रूप से त्रुटि लकड़हारा इवेंट मैनेजर शुरू करता है, और error_logger को निम्न विन्यास के साथ, error_logger को हैंडलर के रूप में जोड़ता है:

#{level => info,
  filter_default => log,
  filters => []}.
ध्यान दें

यह हैंडलर उन घटनाओं को अनदेखा करता है जो error_logger API, या OTP के भीतर से उत्पन्न नहीं होती हैं। इसका मतलब है कि यदि आपका कोड लॉगिंग के लिए लॉगर एपीआई का उपयोग करता है, तो इस हैंडलर द्वारा आपके लॉग ईवेंट को छोड़ दिया जाएगा।

हैंडलर संरक्षित अधिभार नहीं है।

2.8 त्रुटि से निपटने

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

यदि कोई फ़िल्टर या हैंडलर अभी भी क्रैश होता है, तो लॉगर कॉन्फ़िगरेशन से प्रश्न में फ़िल्टर या हैंडलर को हटा देगा, और टर्मिनल पर एक छोटी त्रुटि संदेश प्रिंट करेगा। क्रैश कारण और अन्य विवरण युक्त एक डीबग घटना भी जारी की जाती है।

रिपोर्ट कॉलबैक और लॉग संदेशों के मान्य रूपों के बारे में अधिक जानकारी के लिए अनुभाग Log Message देखें।

2.9 उदाहरण: फ़ाइल में जानकारी की घटनाओं को लॉग करने के लिए एक हैंडलर जोड़ें

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

1> logger:set_primary_config(level, info).
ok

या केवल एक या कुछ मॉड्यूल के लिए स्तर सेट करें:

2> logger:set_module_level(mymodule, info).
ok

यह जानकारी घटनाओं को डिफ़ॉल्ट हैंडलर से गुजरने की अनुमति देता है, और टर्मिनल पर भी मुद्रित किया जा सकता है। यदि कई जानकारी ईवेंट हैं, तो इसके बजाय इन्हें किसी फ़ाइल में प्रिंट करना उपयोगी हो सकता है।

पहले, डिफ़ॉल्ट हैंडलर के लॉग स्तर को notice करने के लिए सेट करें, इसे जानकारी की घटनाओं को टर्मिनल तक प्रिंट करने से रोकें:

3> logger:set_handler_config(default, level, notice).
ok

फिर, एक नया हैंडलर जोड़ें जो फ़ाइल करने के लिए प्रिंट करता है। आप हैंडलर मॉड्यूल का उपयोग कर सकते हैं logger_std_h(3) , और टाइप करें {file,File} ।]

4> Config = #{config => #{type => {file,"./info.log"}}, level => info}.
#{config => #{type => {file,"./info.log"}},level => info}
5> logger:add_handler(myhandler, logger_std_h, Config).
ok

चूंकि filter_default log करने के लिए डिफॉल्ट करता है, इसलिए यह हैंडलर अब सभी लॉग ईवेंट प्राप्त करता है। यदि आप फ़ाइल में केवल ईवेंट जानकारी चाहते हैं, तो आपको सभी गैर-जानकारी इवेंट्स को रोकने के लिए एक फ़िल्टर जोड़ना होगा। अंतर्निहित फ़िल्टर logger_filters:level/2 यह कर सकता है:

6> logger:add_handler_filter(myhandler, stop_non_info, {fun logger_filters:level/2, {stop, neq, info}}).
ok

फ़िल्टर और filter_default कॉन्फ़िगरेशन पैरामीटर के बारे में अधिक जानकारी के लिए अनुभाग Filters देखें।

2.10 उदाहरण: एक हैंडलर लागू करें

लकड़हारा (3) मैनुअल पेज में सेक्शन Handler Callback Functions का वर्णन करता है जिसे लॉगर हैंडलर के लिए लागू किया जा सकता है।

एक हैंडलर कॉलबैक मॉड्यूल निर्यात करना चाहिए:

  • log(Log, Config)

यह वैकल्पिक रूप से निम्नलिखित में से कुछ या सभी को निर्यात कर सकता है:

  • adding_handler(Config)
  • removing_handler(Config)
  • changing_config(OldConfig, NewConfig)

जब एक हैंडलर जोड़ा जाता है, उदाहरण के लिए logger:add_handler/3 लिए एक कॉल logger:add_handler/3 , लकड़हारा पहले HModule:adding_handler(Config) कहता है। यदि यह फ़ंक्शन {ok,Config1} , तो लकड़हारा विन्यास डेटाबेस में logger:add_handler/3 और logger:add_handler/3 कॉल रिटर्न logger:add_handler/3 है। इसके बाद, हैंडलर स्थापित किया गया है और HModule:log/2 को कॉल के रूप में लॉग ईवेंट प्राप्त करने के लिए तैयार होना चाहिए।

एक हैंडलर को logger:remove_handler(Id) कहकर हटाया जा सकता है। लकड़हारा HModule:removing_handler(Config) कॉल HModule:removing_handler(Config) , और कॉन्फ़िगरेशन डेटाबेस से हैंडलर के कॉन्फ़िगरेशन को हटा देता है।

जब set_handler_config/2,3 या update_handler_config/2 कहा जाता है, तो लकड़हारा HModule:changing_config(OldConfig, NewConfig) । यदि यह फ़ंक्शन {ok,NewConfig1} , तो लॉगर कॉन्फ़िगरेशन डेटाबेस में NewConfig1 लिखता है।

टर्मिनल पर प्रिंट करने वाला एक साधारण हैंडलर निम्नानुसार लागू किया जा सकता है:

-module(myhandler1).
-export([log/2]).

log(LogEvent, #{formatter := {FModule, FConfig}}) ->
    io:put_chars(FModule:format(LogEvent, FConfig)).

ध्यान दें कि उपरोक्त हैंडलर में कोई अधिभार संरक्षण नहीं है, और सभी लॉग इवेंट क्लाइंट प्रक्रिया से सीधे मुद्रित होते हैं।

अधिभार संरक्षण की जानकारी और उदाहरणों के लिए, कृपया Protecting the Handler from Overload करने वाले अनुभाग, और logger_std_h(3) और logger_disk_log_h(3) के कार्यान्वयन का logger_std_h(3) logger_disk_log_h(3)

निम्नलिखित एक हैंडलर का एक सरल उदाहरण है जो एक एकल प्रक्रिया के माध्यम से एक फ़ाइल में लॉग करता है:

-module(myhandler2).
-export([adding_handler/1, removing_handler/1, log/2]).
-export([init/1, handle_call/3, handle_cast/2, terminate/2]).

adding_handler(Config) ->
    MyConfig = maps:get(config,Config,#{file => "myhandler2.log"}),
    {ok, Pid} = gen_server:start(?MODULE, MyConfig, []),
    {ok, Config#{config => MyConfig#{pid => Pid}}}.

removing_handler(#{config := #{pid := Pid}}) ->
    gen_server:stop(Pid).

log(LogEvent,#{config := #{pid := Pid}} = Config) ->
    gen_server:cast(Pid, {log, LogEvent, Config}).

init(#{file := File}) ->
    {ok, Fd} = file:open(File, [append, {encoding, utf8}]),
    {ok, #{file => File, fd => Fd}}.

handle_call(_, _, State) ->
    {reply, {error, bad_request}, State}.

handle_cast({log, LogEvent, Config}, #{fd := Fd} = State) ->
    do_log(Fd, LogEvent, Config),
    {noreply, State}.

terminate(_Reason, #{fd := Fd}) ->
    _ = file:close(Fd),
    ok.

do_log(Fd, LogEvent, #{formatter := {FModule, FConfig}}) ->
    String = FModule:format(LogEvent, FConfig),
    io:put_chars(Fd, String).

2.11 हैंडलर को ओवरलोड से बचाना

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

संदेश कतार की लंबाई

हैंडलर प्रक्रिया अपनी संदेश कतार की लंबाई पर नज़र रखती है और मौजूदा लंबाई एक विन्यास सीमा से अधिक होने पर कुछ प्रकार की कार्रवाई करती है। उद्देश्य हैंडलर को अंदर रखना है, या जितनी जल्दी हो सके हैंडलर को प्राप्त करना है, एक राज्य जहां यह आने वाली लॉग घटनाओं की गति के साथ रख सकता है। हैंडलर का मेमोरी उपयोग कभी भी बड़ा और बड़ा नहीं होना चाहिए, क्योंकि इससे हैंडलर क्रैश हो जाएगा। ये तीन थ्रेसहोल्ड, संबंधित क्रियाओं के साथ मौजूद हैं:

sync_mode_qlen

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

10 संदेशों में चूक।

drop_mode_qlen

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

200 संदेशों में चूक।

flush_qlen

यदि संदेश कतार की लंबाई इस सीमा से अधिक हो जाती है, तो एक फ़्लश (डिलीट) ऑपरेशन होता है। ईवेंट को फ्लश करने के लिए, हैंडलर संदेश पंक्ति में संदेशों को बिना लॉग इन किए लूप में प्राप्त करके डिस्क्राइब करता है। एक तुल्यकालिक लॉग अनुरोध से प्रतिक्रिया के लिए प्रतीक्षा कर रहे क्लाइंट प्रक्रियाओं को हैंडलर से एक उत्तर प्राप्त होता है जो दर्शाता है कि अनुरोध गिरा दिया गया है। हैंडलर प्रक्रिया फ्लश लूप के दौरान अपनी प्राथमिकता बढ़ाती है ताकि यह सुनिश्चित किया जा सके कि ऑपरेशन के दौरान कोई नई घटना नहीं हुई है। ध्यान दें कि फ्लश ऑपरेशन करने के बाद, हैंडलर लॉग में जानकारी छापता है कि कितने ईवेंट हटाए गए हैं।

1000 संदेशों में चूक।

अधिभार संरक्षण एल्गोरिथ्म को ठीक से काम करने के लिए, यह आवश्यक है कि:

sync_mode_qlen =< drop_mode_qlen =< flush_qlen

और वह:

drop_mode_qlen > 1

कुछ मोड को अक्षम करने के लिए, निम्न कार्य करें:

  • यदि sync_mode_qlen 0 सेट है, तो सभी लॉग ईवेंट को सिंक्रोनाइज़ किया जाता है। अर्थात, एसिंक्रोनस लॉगिंग अक्षम है।
  • अगर sync_mode_qlen को उसी मान पर सेट किया जाता है जैसे drop_mode_qlen , सिंक्रोनस मोड अक्षम है। यही है, हैंडलर हमेशा अतुल्यकालिक मोड में चलता है, जब तक कि ड्रॉपिंग या फ्लशिंग को लागू नहीं किया जाता है।
  • यदि drop_mode_qlen को drop_mode_qlen के समान मान पर सेट किया जाता है, तो ड्रॉप मोड अक्षम है और कभी भी घटित नहीं हो सकता है।

उच्च लोड परिदृश्यों के दौरान, हैंडलर संदेश कतार की लंबाई शायद ही कभी एक रैखिक और पूर्वानुमेय तरीके से बढ़ती है। इसके बजाय, जब भी हैंडलर प्रक्रिया निर्धारित की जाती है, तो इसमें संदेश कतार में प्रतीक्षा कर रहे संदेशों की लगभग मनमानी संख्या हो सकती है। यह इस कारण से है कि अधिभार संरक्षण तंत्र जल्दी से अभिनय करने पर केंद्रित है, और काफी तेज, जैसे कि तुरंत संदेश छोड़ने या फ्लशिंग संदेश, जब एक बड़ी कतार की लंबाई का पता लगाया जाता है।

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

एक कॉन्फ़िगरेशन उदाहरण:

logger:add_handler(my_standard_h, logger_std_h,
                   #{config => #{type => {file,"./system_info.log"},
                                 sync_mode_qlen => 100,
                                 drop_mode_qlen => 1000,
                                 flush_qlen => 2000}}).

लॉग अनुरोध के फटने को नियंत्रित करना

लॉग ईवेंट की बड़ी मात्रा में - हैंडलर द्वारा बहुत कम समय में प्राप्त की गई कई घटनाएं - संभावित रूप से समस्याएं पैदा कर सकती हैं, जैसे:

  • लॉग फाइलें बहुत बड़ी हो जाती हैं, बहुत जल्दी।
  • परिपत्र लॉग बहुत जल्दी लपेटता है ताकि महत्वपूर्ण डेटा ओवरराइट हो जाए।
  • लिखें बफ़र्स बड़े होते हैं, जो फ़ाइल सिंक ऑपरेशन को धीमा कर देता है।

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

burst_limit_enable

मूल्य true फट नियंत्रण को सक्षम false करता है और इसे निष्क्रिय करता है।

true अवहेलना।

burst_limit_max_count

यह एक burst_limit_window_time समय सीमा के भीतर संभालने के लिए घटनाओं की अधिकतम संख्या है । सीमा समाप्त होने के बाद, समय सीमा समाप्त होने तक क्रमिक घटनाओं को छोड़ दिया जाता है।

500 घटनाओं के लिए चूक ।

burst_limit_window_time

का पिछला विवरण देखें burst_limit_max_count

1000 मिलीसेकंड के लिए डिफ़ॉल्ट ।

एक कॉन्फ़िगरेशन उदाहरण:

logger:add_handler(my_disk_log_h, logger_disk_log_h,
                   #{config => #{file => "./my_disk_log",
                                 burst_limit_enable => true,
                                 burst_limit_max_count => 20,
                                 burst_limit_window_time => 500}}).

एक अतिभारित हैंडलर को समाप्त करना

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

overload_kill_enable

मान true सुविधा को सक्षम false करता है और इसे अक्षम करता है।

false अवहेलना।

overload_kill_qlen

यह अधिकतम अनुमत कतार लंबाई है। यदि संदेश कतार इससे बड़ी होती है, तो हैंडलर प्रक्रिया समाप्त हो जाती है।

20000 संदेशों में चूक ।

overload_kill_mem_size

यह अधिकतम मेमोरी आकार है जिसे हैंडलर प्रक्रिया का उपयोग करने की अनुमति है। यदि हैंडलर इससे बड़ा हो जाता है, तो प्रक्रिया समाप्त हो जाती है।

करने के लिए चूक 3000000 बाइट्स।

overload_kill_restart_after

यदि हैंडलर समाप्त हो जाता है, तो मिलीसेकंड में निर्दिष्ट देरी के बाद यह स्वचालित रूप से पुनरारंभ होता है। मान infinity पुनरारंभ को रोकता है।

5000 मिलीसेकंड के लिए डिफ़ॉल्ट ।

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

ध्यान दें

लॉग इवेंट के आकार हैंडलर की स्मृति आवश्यकताओं को प्रभावित करते हैं। लॉग इवेंट्स के आकार को सीमित करने के बारे में जानकारी के लिए, logger_formatter(3) मैन्युअल पृष्ठ देखें।

2.12 यह भी पढ़ें:

disk_log , error_logger(3) , Logger , logger_disk_log_h(3) , logger_filters(3) , logger_formatter(3) , logger_std_h(3) , sasl(6)

Original text