Elixir 1.7

Logger




elixir

Logger

अमृत ​​अनुप्रयोगों के लिए एक लकड़हारा।

इसमें कई विशेषताएं शामिल हैं:

  • डिबग, सूचना, चेतावनी और त्रुटि स्तर प्रदान करता है।

  • कई बैकएंड का समर्थन करता है जो Logger में प्लग किए जाने पर स्वचालित रूप से पर्यवेक्षित होते हैं।

  • Logger बैकएंड को क्लॉगिंग से बचाने के लिए क्लाइंट पर फॉर्मेट्स और ट्रंकट्स को मैसेज करता है।

  • जब आवश्यक हो, लेकिन स्थिर रहने के लिए सिंक और एसिंक्स मोड के बीच वैकल्पिक, लेकिन तनाव में होने पर बैकस्पेस भी लागू करें।

  • Erlang के :error_logger :logger (Erlang / OTP 21 से) को Elixir सिंटैक्स में शब्दों को बदलने के लिए या इससे पहले के Erlang / OTP संस्करणों में Erlang :error_logger को ओवरफ्लो होने से बचाने के लिए लपेटता है।

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

def delete_user(user) do
  Logger.info "Deleting user from the system: #{inspect(user)}"
  # ...
end

Logger.info/2 मैक्रो प्रदान करता है :info स्तर पर संदेश। ध्यान दें कि info/2 को दिए गए तर्कों का मूल्यांकन केवल तभी किया जाएगा जब कोई संदेश लॉग किया गया हो। उदाहरण के लिए, यदि लकड़हारा स्तर इसके लिए सेट किया गया है :warn :info संदेश कभी लॉग नहीं किए जाते हैं और इसलिए ऊपर दिए गए तर्क भी निष्पादित नहीं किए जाएंगे।

अन्य स्तरों के लिए अतिरिक्त मैक्रो हैं।

लकड़हारा भी लॉग कमांड को पूरी तरह से हटाने की अनुमति देता है :compile_time_purge_matching विकल्प (नीचे देखें)।

डायनेमिक लॉगिंग संदेशों के लिए, bare_log/3 देखें। लेकिन ध्यान दें कि bare_log/3 हमेशा अपने तर्कों का मूल्यांकन करते हैं (जब तक कि तर्क एक अनाम फ़ंक्शन नहीं है)।

स्तर

समर्थित स्तर हैं:

  • :debug - डिबग से संबंधित संदेशों के लिए
  • :info - किसी भी प्रकार की जानकारी के लिए
  • :warn - चेतावनियों के लिए
  • :error - त्रुटियों के लिए

विन्यास

Logger विन्यास की एक विस्तृत श्रृंखला का समर्थन करता है।

यह कॉन्फ़िगरेशन तीन श्रेणियों में विभाजित है:

  • एप्लिकेशन कॉन्फ़िगरेशन - :logger एप्लिकेशन शुरू होने से पहले सेट किया जाना चाहिए

  • रनटाइम कॉन्फ़िगरेशन - :logger अनुप्रयोग शुरू होने से पहले सेट किया जा सकता है, लेकिन रनटाइम के दौरान बदला जा सकता है

  • एरलैंग विन्यास - विकल्प जो एरलांग की लॉगिंग सुविधाओं के साथ एकीकरण को संभालते हैं

अनुप्रयोग कॉन्फ़िगरेशन

निम्न कॉन्फ़िगरेशन कॉन्फ़िगरेशन फ़ाइलों के माध्यम से सेट किया जाना चाहिए (जैसे config/config.exs ) :logger अनुप्रयोग शुरू होने से पहले।

  • :backends - उपयोग किए जाने वाले बैकएंड। डिफ़ॉल्ट [:console] । अधिक जानकारी के लिए "बैकेंड" अनुभाग देखें।

  • :compile_time_application - संकलन समय पर कॉन्फ़िगर किए गए मान में :application मेटाडेटा मान सेट करता है। यह कॉन्फ़िगरेशन आमतौर पर केवल Logger.debug/2 करने के लिए Logger.debug/2 , Logger.info/2 , आदि कॉल की शैली के लिए मेटाडेटा में एप्लिकेशन को जोड़ने के लिए उपकरण बनाने के लिए उपयोगी है।

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

उदाहरण के लिए, कॉन्फ़िगर करने के लिए :backends और शुद्ध सभी कॉल जो संकलित समय से कम स्तर के साथ होती हैं :info एक config/config.exs फ़ाइल में :info :

config :logger,
  backends: [:console],
  compile_time_purge_matching: [
    [level_lower_than: :info]
  ]

यदि आप नामित एप्लिकेशन से सभी लॉग कॉल को शुद्ध करना चाहते हैं :foo और केवल Bar.foo/3 से त्रुटियां Bar.foo/3 , तो आप दो अलग-अलग मैच सेट कर सकते हैं:

config :logger,
  compile_time_purge_matching: [
    [application: :foo],
    [module: Bar, function: "foo/3", level_lower_than: :error]
  ]

रनटाइम कॉन्फ़िगरेशन

नीचे सभी कॉन्फ़िगरेशन को कॉन्फ़िगर फ़ाइलों (जैसे config/config.exs ) के माध्यम से सेट किया जा सकता है, लेकिन Logger.configure/1 माध्यम से रनटाइम के दौरान गतिशील रूप से बदल दिया गया है।

  • :level - लॉगिंग स्तर। कॉन्फ़िगर किए गए स्तर से कम गंभीरता के साथ किसी भी संदेश को लॉग करने का प्रयास करने से संदेश को अनदेखा किया जाएगा। ध्यान रखें कि प्रत्येक बैकएंड का अपना विशिष्ट स्तर भी हो सकता है।

  • :utc_log - जब true होता true , तो लॉग में UTC का उपयोग करता है। डिफ़ॉल्ट रूप से यह स्थानीय समय का उपयोग करता है (यानी, यह false को false )।

  • :truncate - अधिकतम संदेश आकार लॉग करने के लिए (बाइट्स में)। 8192 बाइट्स की कमी। ध्यान दें कि यह विन्यास अनुमानित है। काटे गए संदेशों में अंत में " (truncated)" । परमाणु :infinity को इस व्यवहार को निष्क्रिय करने के लिए पारित किया जा सकता है।

  • :sync_threshold - अगर Logger प्रबंधक से अधिक है :sync_threshold को अपनी कतार में :sync_threshold मैसेजेस, Logger सिंक मोड में बदल जाएगा, ताकि ग्राहकों को :sync_threshold लागू किया जा सके। एक बार कतार में संदेशों की संख्या sync_threshold * 0.75 संदेशों तक कम हो जाने के बाद sync_threshold * 0.75 मोड में लौट sync_threshold * 0.75 । 20 संदेशों में चूक। :sync_threshold सिंक मोड को मजबूर करने के लिए 0 पर सेट किया जा सकता है

  • :discard_threshold - यदि Logger प्रबंधक से अधिक है :discard_threshold अपनी कतार में :discard_threshold संदेश को छोड़ें , तो Logger मोड को त्यागने के लिए बदल जाएगा और संदेश सीधे ग्राहकों में छोड़ दिए जाएंगे। एक बार कतार में संदेशों की संख्या को discard_threshold * 0.75 लिए कम हो जाने के discard_threshold * 0.75 संदेश को discard_threshold * 0.75 करने पर Logger सिंक मोड में लौट discard_threshold * 0.75 । 500 संदेशों में चूक।

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

उदाहरण के लिए, config/config.exs फ़ाइल में :level और :truncate config/config.exs विकल्पों को कॉन्फ़िगर करने के लिए:

config :logger,
  level: :warn,
  truncate: 4096

लॉगर कॉन्फ़िगरेशन में त्रुटि

Erlang की लॉगिंग फ़ंक्शंस के आसपास Logger के रैपर पर निम्न कॉन्फ़िगरेशन लागू होता है। :logger आवेदन शुरू होने से पहले नीचे दिए गए सभी कॉन्फ़िगरेशन सेट होने चाहिए।

  • :handle_otp_reports - OTP को :handle_otp_reports को रिपोर्ट करता है ताकि वे :handle_otp_reports शब्दों में स्वरूपित हों। यह प्रभावी रूप से Erlang मानक लकड़हारे को निष्क्रिय कर देता है। true अवहेलना।

  • :handle_sasl_reports - :handle_sasl_reports पर्यवेक्षक, दुर्घटना और प्रगति रिपोर्ट को पुनर्निर्देशित करता है ताकि वे :handle_sasl_reports शब्दों में स्वरूपित हों। आपके आवेदन की गारंटी होनी चाहिए :sasl पहले शुरू किया गया है :logger । इसका मतलब यह है कि आप कुछ प्रारंभिक रिपोर्टें लिख सकते हैं, जब तक लकड़हारा आवेदन अंदर नहीं होता तब तक एर्लांग सिंटैक्स में लिखा गया है।

Erlang / OTP 21 से :handle_sasl_reports ही प्रभाव पड़ता है यदि :handle_otp_reports सच है।

निम्नलिखित कॉन्फ़िगरेशन केवल Erlang / OTP 20 और पहले के लिए लागू होते हैं:

  • :discard_threshold_for_error_logger - if :error_logger में इसके इनबॉक्स में discard_threshold अधिक से अधिक संदेश हैं, संदेश तब तक छोड़ दिए जाएंगे जब तक संदेश कतार discard_threshold * 0.75 प्रविष्टियां नहीं हो जाती। थ्रेसहोल्ड संदेशों के 10% संसाधित होने के बाद एक बार फिर से दहलीज की जाँच की जाएगी, ताकि संदेशों को लगातार गिराए जाने से बचाया जा सके। उदाहरण के लिए, यदि थ्रेशोल्ड 500 (डिफ़ॉल्ट) और इनबॉक्स में 600 संदेश हैं, तो 225 संदेश गिर जाएंगे, इनबॉक्स को 375 (0.75 थ्रेशोल्ड) प्रविष्टियों तक पहुंचाया जाएगा और थ्रेसहोल्ड की जांच करने से पहले 50 (0.1 थ्रेशोल्ड) संदेशों को संसाधित किया जाएगा। एक बार फिर।

उदाहरण के लिए, Logger को कॉन्फ़िगर करने के लिए सभी Erlang संदेशों को एक config/config.exs फ़ाइल का उपयोग करके पुनर्निर्देशित करें:

config :logger,
  handle_otp_reports: true,
  handle_sasl_reports: true

इसके अलावा, Logger एर्लांग द्वारा भेजे गए संदेशों को अनुवादकों के माध्यम से एक अमृत प्रारूप में अनुवाद करने की अनुमति देता है। अनुवादक किसी भी समय add_translator/1 और remove_translator/1 API के साथ जोड़ सकते हैं। अधिक जानकारी के लिए Logger.Translator जाँच करें।

backends

Logger विभिन्न बैकेंड का समर्थन करता है जहां लॉग संदेश लिखे जाते हैं।

डिफ़ॉल्ट रूप से उपलब्ध बैकएंड हैं:

  • :console - :console को संदेश भेजता है (डिफ़ॉल्ट रूप से सक्षम)

डेवलपर्स अपने स्वयं के बैकएंड को भी लागू कर सकते हैं, एक विकल्प जो नीचे और अधिक विवरण में खोजा गया है।

प्रारंभिक बैकएंड के माध्यम से लोड किया जाता है :backends कॉन्फ़िगरेशन, जिसे पहले सेट किया जाना चाहिए :logger आवेदन शुरू किया जाता है।

कंसोल बैकएंड

कंसोल बैकेंड संदेशों को कंसोल पर प्रिंट करके लॉग करता है। यह निम्नलिखित विकल्पों का समर्थन करता है:

  • :level - इस बैकएंड द्वारा लॉग किया जाने वाला स्तर। ध्यान दें कि संदेश सामान्य रूप से फ़िल्टर किए जाते हैं :level कॉन्फ़िगरेशन :logger आवेदन पहले।

  • :format - लॉग को प्रिंट करने के लिए उपयोग किया जाने वाला प्रारूप संदेश। डिफ़ॉल्ट: "\n$time $metadata[$level] $levelpad$message\n" । यह एक {module, function} ट्यूपल भी हो सकता है जो लॉग स्तर, संदेश, वर्तमान टाइमस्टैम्प और मेटाडेटा के साथ लगाया जाता है।

  • :metadata - मेटाडेटा $metadata द्वारा मुद्रित किया जाना है। एक खाली सूची (कोई मेटाडाटा) में चूक। सेटिंग :metadata को :all सभी मेटाडेटा को प्रिंट करता है। अधिक जानकारी के लिए "मेटाडेटा" अनुभाग देखें।

  • :colors - रंग विकल्पों की एक खोजशब्द सूची।

  • :device - त्रुटि संदेश लॉग करने के लिए डिवाइस। :user लिए डिफ़ॉल्ट :user लेकिन इसे कुछ और जैसे :standard_error बदला जा सकता है।

  • :max_buffer - IO डिवाइस से पुष्टिकरण की प्रतीक्षा में बफर में अधिकतम ईवेंट (डिफ़ॉल्ट: 32)। एक बार बफर भर जाने के बाद, बैकएंड तब तक ब्लॉक रहेगा जब तक कि एक पुष्टिकरण प्राप्त नहीं हो जाता।

इसमें समर्थित कुंजी :colors कीवर्ड सूची हैं:

  • :enabled - बूलियन मान जो रंग को चालू और बंद करने की अनुमति देता है। डिफ़ॉल्ट: IO.ANSI.enabled?/0

  • :debug - डिबग संदेशों के लिए रंग। चूक :cyan

  • :info - सूचना संदेशों के लिए रंग। के लिए दोष :normal

  • :warn - चेतावनी संदेशों के लिए रंग। के लिए दोष :yellow

  • :error - त्रुटि संदेशों के लिए रंग। के लिए दोष :red

रंगों और विशेषताओं की सूची के लिए IO.ANSI मॉड्यूल देखें।

यहाँ कॉन्फ़िगर करने के तरीके का एक उदाहरण है :console बैकएंड में एक config/config.exs फ़ाइल:

config :logger, :console,
  format: "\n$time $metadata[$level] $levelpad$message\n",
  metadata: [:user_id]

मेटाडाटा

Logger.metadata/1 माध्यम से उपयोगकर्ता द्वारा प्रदान की जाने वाली कुंजियों के अलावा, निम्नलिखित अतिरिक्त कुंजियाँ उपलब्ध हैं :metadata :

  • :application - वर्तमान आवेदन

  • :module - वर्तमान मॉड्यूल

  • :function - वर्तमान फ़ंक्शन

  • :file - वर्तमान फ़ाइल

  • :line - वर्तमान लाइन

  • :pid - वर्तमान प्रक्रिया पहचानकर्ता

  • :crash_reason - पहले तर्क के रूप में फेंक / त्रुटि / निकास कारण के साथ एक दो-तत्व टपल और दूसरे के रूप में स्टैकट्रेस। एक थ्रो हमेशा {:nocatch, term} । एक त्रुटि हमेशा एक Exception संरचना है। अन्य सभी प्रविष्टियाँ बाहर हैं। कंसोल बैकएंड डिफ़ॉल्ट रूप से इस मेटाडेटा को अनदेखा करता है, लेकिन यह अन्य बैकेंड के लिए उपयोगी हो सकता है, जैसे कि तृतीय-पक्ष सेवाओं में त्रुटियों की रिपोर्ट करने वाले

  • :initial_call - प्रारंभिक कॉल जिसने प्रक्रिया शुरू की

  • :registered_name - प्रक्रिया एक परमाणु के रूप में पंजीकृत नाम

ध्यान दें कि सभी मेटाडेटा वैकल्पिक हैं और हमेशा उपलब्ध नहीं हो सकते हैं। Logger मैक्रोज़ का उपयोग करते समय :module :function :line और इसी तरह के मेटाडेटा को स्वचालित रूप से शामिल किया जाता है। Logger.bare_log/3 में डिफ़ॉल्ट रूप से :pid परे कोई मेटाडेटा शामिल नहीं है। अन्य मेटाडेटा, जैसे :crash_reason :initial_call , और :registered_name को Erlang / OTP क्रैश रिपोर्ट से निकाला जाता है और केवल उन मामलों में उपलब्ध है।

कस्टम स्वरूपण

कंसोल बैकेंड आपको अपने लॉग संदेशों के :format को :format विकल्प के साथ अनुकूलित करने की अनुमति देता है।

आप सेट कर सकते हैं :format यदि आप अपना स्वयं का प्रारूप फ़ंक्शन प्रदान करना चाहते हैं तो या तो एक स्ट्रिंग या एक {module, function} ट्यूपल को प्रारूपित करें। यहाँ कॉन्फ़िगर करने के तरीके का एक उदाहरण है :console बैकएंड में एक config/config.exs फ़ाइल:

config :logger, :console,
  format: {MyConsoleLogger, :format}

और यहाँ एक उदाहरण है कि आप कैसे MyConsoleLogger.format/4 को उपरोक्त विन्यास से परिभाषित कर सकते हैं:

defmodule MyConsoleLogger do
  def format(level, message, timestamp, metadata) do
    # Custom formatting logic...
  end
end

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

defmodule MyConsoleLogger do
  def format(level, message, timestamp, metadata) do
    # Custom formatting logic...
  rescue
    _ -> "could not format: #{inspect({level, message, metadata}})"
  end
end

{module, function} को चार तर्कों के साथ मंगाया जाएगा:

  • लॉग स्तर: एक परमाणु
  • संदेश: यह आम तौर पर chardata है, लेकिन कुछ मामलों में यह नहीं हो सकता है। चूंकि स्वरूपण फ़ंक्शन को कभी भी विफल नहीं होना चाहिए, आपको संदेश कुछ भी होने के लिए तैयार करने की आवश्यकता है (और ऊपर दिए उदाहरण में rescue जैसा कुछ करें)
  • वर्तमान टाइमस्टैम्प: एक प्रकार का शब्द Logger.Formatter.time/0
  • मेडेटा: एक कीवर्ड सूची

आप Logger.Formatter में फ़ॉर्मेटिंग के बारे में अधिक पढ़ सकते हैं।

कस्टम बैकएंड

कोई भी डेवलपर अपना Logger बैकएंड बना सकता है। चूँकि Logger एक इवेंट मैनेजर द्वारा संचालित है :gen_event , एक नया बैकएंड लिखना एक इवेंट हैंडलर बनाने की बात है, जैसा कि :gen_event डॉक्यूमेंट में वर्णित है।

अब से, हम "कस्टम हैंडलर" शब्द का उपयोग अपने कस्टम बैकेंड को संदर्भित करने के लिए करेंगे, जैसा कि हम कार्यान्वयन विवरण में करते हैं।

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

एक बार आरंभ करने के बाद, हैंडलर को निम्नलिखित प्रारूप में घटनाओं को संभालने के लिए डिज़ाइन किया जाना चाहिए:

{level, group_leader, {Logger, message, timestamp, metadata}} | :flush

कहा पे:

  • level इनमें से एक है :debug , :info :warn , या :error , जैसा कि पहले वर्णित है
  • group_leader प्रक्रिया का समूह नेता है जिसने संदेश को लॉग किया
  • {Logger, message, timestamp, metadata} एक टपल है जिसमें लॉग संदेश के बारे में जानकारी है:

    • पहला तत्व हमेशा परमाणु Logger
    • message वास्तविक संदेश है (chardata के रूप में)
    • मैसेज को लॉग करने के लिए timestamp एक timestamp है, {{year, month, day}, {hour, minute, second, millisecond}} टपल के रूप में
    • metadata की एक कीवर्ड सूची है जिसका उपयोग संदेश लॉग करते समय किया जाता है

यह अनुशंसा की जाती है कि हैंडलर उन संदेशों को अनदेखा करें जहां समूह लीडर हैंडलर स्थापित होने की तुलना में एक अलग नोड में है। उदाहरण के लिए:

def handle_event({_level, gl, {Logger, _, _, _}}, state)
    when node(gl) != node() do
  {:ok, state}
end

घटना के मामले में :flush हैंडलर को किसी भी लंबित डेटा को फ्लश करना चाहिए। इस घटना को flush/0 द्वारा ट्रिगर किया गया है।

इसके अलावा, बैकएंड को config_backend configure_backend/2 फ़ंक्शन के माध्यम से configure_backend/2 किया जा सकता है जिसमें निम्न प्रारूप की कॉल को संभालने के लिए इवेंट हैंडलर की आवश्यकता होती है:

{:configure, options}

जहाँ options एक खोजशब्द सूची है। कॉल का परिणाम configure_backend/2 द्वारा लौटाया गया परिणाम है। सफल कॉन्फ़िगरेशन के लिए अनुशंसित रिटर्न मान है :ok

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

  • :level - उस बैकएंड के लिए लॉगिंग स्तर
  • :format - उस बैकएंड के लिए लॉगिंग प्रारूप
  • :metadata - मेटाडेटा उस बैकएंड में शामिल करने के लिए

इस खंड में सिफारिशों को कैसे प्रबंधित करें और मौजूदा विकल्पों को कैसे संसाधित करें, इस पर उदाहरण के लिए, Logger.Backends.Console के कार्यान्वयन को Logger.Backends.Console

सारांश

प्रकार

backend()
level()
message()
metadata()

कार्य

add_backend (बैकेंड, opts \\ [])

एक नया बैकेंड जोड़ता है

add_translator/1

एक नया अनुवादक जोड़ता है

bare_log/3

किसी संदेश को गतिशील रूप से लॉग करता है

तुलना_वेल्स (स्तर, स्तर)

लॉग स्तर की तुलना करता है

configure(options)

लकड़हारा को कॉन्फ़िगर करता है

configure_backend/2

दिए गए बैकएंड को कॉन्फ़िगर करता है

डीबग (chardata_or_fun, मेटाडेटा \\ [])

एक डीबग संदेश लॉग करता है

disable(pid)

वर्तमान प्रक्रिया के लिए लॉगिंग अक्षम करता है

enable(pid)

वर्तमान प्रक्रिया के लिए लॉगिंग सक्षम करता है

त्रुटि (chardata_or_fun, मेटाडेटा \\ [])

एक त्रुटि संदेश लॉग करता है

flush/0

लकड़हारे को भगाता है

info/2

एक जानकारी संदेश लॉग करता है

level()

Logger स्तर Logger है

लॉग (स्तर, chardata_or_fun, मेटाडेटा \\ [])

दिए गए level साथ एक संदेश लॉग करता level

metadata()

वर्तमान प्रक्रिया मेटाडेटा पढ़ता है

metadata(keyword)

वर्तमान प्रक्रिया मेटाडेटा को दिए गए कीवर्ड सूची के अनुसार बदल देती है

remove_backend (बैकएंड, opts \\ [])

एक बैकएंड निकालता है

remove_translator/1

एक अनुवादक निकालता है

reset_metadata (कीवर्ड \\ [])

वर्तमान प्रक्रिया मेटाडेटा को दिए गए कीवर्ड सूची में रीसेट करता है

चेतावनी (chardata_or_fun, मेटाडेटा \\ [])

चेतावनी संदेश लॉग करता है

प्रकार

बैकएंड ()

backend() :: :gen_event.handler()

स्तर ()

level() :: :error | :info | :warn | :debug

संदेश()

message() :: IO.chardata() | String.Chars.t()

मेटाडाटा ()

metadata() :: keyword()

कार्य

add_backend (बैकेंड, opts \\ [])

add_backend(atom(), keyword()) :: Supervisor.on_start_child()

एक नया बैकेंड जोड़ता है।

विकल्प

  • :flush - जब true होता true , तो बैकएंड जोड़े जाने से पहले Logger को भेजे गए सभी संदेशों की गारंटी दी जाती है

add_translator (अनुवादक)

add_translator({module(), function :: atom()}) :: :ok

एक नया अनुवादक जोड़ता है।

bare_log (स्तर, chardata_or_fun, मेटाडेटा \\ [])

bare_log(
  level(),
  message() | (() -> message() | {message(), keyword()}),
  keyword()
) :: :ok | {:error, :noproc} | {:error, term()}

किसी संदेश को गतिशील रूप से लॉग करता है।

log/3 , debug/2 , info/2 , और दोस्तों के विपरीत, bare_log/3 दिए गए तर्कों का हमेशा मूल्यांकन किया जाता है। हालांकि, आप bare_log/3 लिए अनाम फ़ंक्शन पास कर सकते हैं और उनका मूल्यांकन केवल तभी किया जाएगा जब लॉग करने के लिए कुछ हो।

तुलना_वेल्स (स्तर, स्तर)

compare_levels(level(), level()) :: :lt | :eq | :gt

लॉग स्तर की तुलना करता है।

दो लॉग स्तर प्राप्त करता है और right स्तर और रिटर्न के खिलाफ left स्तर की तुलना करता है:

  • :lt left अगर left right से कम है
  • :eq यदि left और right बराबर हैं
  • :gt अगर left से right बड़ा है

उदाहरण

iex> Logger.compare_levels(:debug, :warn)
:lt
iex> Logger.compare_levels(:error, :info)
:gt

कॉन्फ़िगर (विकल्प)

configure(keyword()) :: :ok

लकड़हारा को कॉन्फ़िगर करता है।

उपलब्ध विकल्पों के लिए Logger मॉड्यूल प्रलेखन में "रनटाइम कॉन्फ़िगरेशन" अनुभाग देखें।

कॉन्फ़िगर_बैकेंड (बैकएंड, विकल्प)

configure_backend(backend(), keyword()) :: term()

दिए गए बैकएंड को कॉन्फ़िगर करता है।

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

डीबग (chardata_or_fun, मेटाडेटा \\ []) (मैक्रो)

एक डीबग संदेश लॉग करता है।

रिटर्न :ok या {:error, reason} टपल।

उदाहरण

Logger.debug "hello?"
Logger.debug fn -> "dynamically calculated debug" end
Logger.debug fn -> {"dynamically calculated debug", [additional: :metadata]} end

अक्षम करें (पीआईडी)

disable(pid()) :: :ok

वर्तमान प्रक्रिया के लिए लॉगिंग अक्षम करता है।

वर्तमान में एकमात्र स्वीकृत पीआईडी self()

सक्षम (पीआईडी)

enable(pid()) :: :ok

वर्तमान प्रक्रिया के लिए लॉगिंग सक्षम करता है।

वर्तमान में एकमात्र स्वीकृत पीआईडी self()

त्रुटि (chardata_or_fun, मेटाडेटा \\ []) (मैक्रो)

एक त्रुटि संदेश लॉग करता है।

रिटर्न :ok या {:error, reason} टपल।

उदाहरण

Logger.error "oops"
Logger.error fn -> "dynamically calculated error" end
Logger.error fn -> {"dynamically calculated error", [additional: :metadata]} end

फ्लश ()

flush() :: :ok

लकड़हारे को भगाता है।

यह गारंटी देता है कि इस कॉल से पहले Logger को भेजे गए सभी संदेशों को संसाधित किया जाएगा। यह परीक्षण के लिए उपयोगी है और इसे उत्पादन कोड में नहीं कहा जाना चाहिए।

जानकारी (chardata_or_fun, मेटाडेटा \\ []) (मैक्रो)

एक जानकारी संदेश लॉग करता है।

रिटर्न :ok या {:error, reason} टपल।

उदाहरण

Logger.info "mission accomplished"
Logger.info fn -> "dynamically calculated info" end
Logger.info fn -> {"dynamically calculated info", [additional: :metadata]} end

स्तर ()

level() :: level()

Logger स्तर Logger है।

Logger स्तर को configure(options) माध्यम से बदला जा सकता है।

लॉग (स्तर, chardata_or_fun, मेटाडेटा \\ []) (मैक्रो)

दिए गए level साथ एक संदेश लॉग करता level

रिटर्न :ok या {:error, reason} टपल।

मैक्रो debug/2 , warn/2 , info/2 , और error/2 को इस मैक्रो के ऊपर पसंद किया जाता है क्योंकि वे वांछित समय पर Logger को कॉल को पूरी तरह से समाप्त कर सकते हैं यदि वांछित हो ( Logger मॉड्यूल के लिए प्रलेखन देखें)।

मेटाडाटा ()

metadata() :: metadata()

वर्तमान प्रक्रिया मेटाडेटा पढ़ता है।

मेटाडाटा (कीवर्ड)

metadata(metadata()) :: :ok

वर्तमान प्रक्रिया मेटाडेटा को दिए गए कीवर्ड सूची के अनुसार बदल देती है।

यह फ़ंक्शन दी गई कीवर्ड सूची को मौजूदा मेटाडेटा में मर्ज कर देगा, जिसमें कुंजी को nil करने के लिए अपवाद होगा, जो मेटाडेटा से उस कुंजी को हटा देगा।

remove_backend (बैकएंड, opts \\ [])

remove_backend(atom(), keyword()) :: :ok | {:error, term()}

एक बैकएंड निकालता है।

विकल्प

  • :flush - जब true होता true , तो बैकएंडर को हटाने से पहले Logger को भेजे गए सभी संदेशों की गारंटी दी जाती है

remove_translator (अनुवादक)

remove_translator({module(), function :: atom()}) :: :ok

एक अनुवादक निकालता है।

reset_metadata (कीवर्ड \\ [])

reset_metadata(metadata()) :: :ok

वर्तमान प्रक्रिया मेटाडेटा को दिए गए कीवर्ड सूची में रीसेट करता है।

चेतावनी (chardata_or_fun, मेटाडेटा \\ []) (मैक्रो)

चेतावनी संदेश लॉग करता है।

रिटर्न :ok या {:error, reason} टपल।

उदाहरण

Logger.warn "knob turned too far to the right"
Logger.warn fn -> "dynamically calculated warning" end
Logger.warn fn -> {"dynamically calculated warning", [additional: :metadata]} end