Julia 1.0

Logging




julia

Logging

Logging मॉड्यूल घटनाओं के लॉग के रूप में एक संगणना के इतिहास और प्रगति को रिकॉर्ड करने का एक तरीका प्रदान करता है। स्रोत कोड में लॉगिंग स्टेटमेंट डालकर ईवेंट बनाए जाते हैं, उदाहरण के लिए:

@warn "Abandon printf debugging, all ye who enter here!"
┌ Warning: Abandon printf debugging, all ye who enter here!
â”” @ Main REPL[1]:1

सिस्टम अपने स्रोत कोड को println() कॉल करने के साथ कई फायदे प्रदान करता है। सबसे पहले, यह आपको स्रोत कोड को संपादित किए बिना संदेशों की दृश्यता और प्रस्तुति को नियंत्रित करने की अनुमति देता है। उदाहरण के लिए, ऊपर @warn विपरीत

@debug "The sum of some values $(sum(rand(100)))"

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

दूसरा, लॉगिंग टूल आपको कुंजी-मान युग्मों के एक सेट के रूप में प्रत्येक घटना के लिए मनमाना डेटा संलग्न करने की अनुमति देता है। यह आपको बाद के विश्लेषण के लिए स्थानीय चर और अन्य कार्यक्रम राज्य पर कब्जा करने की अनुमति देता है। उदाहरण के लिए, स्थानीय सरणी चर A और सदिश v का योग जिसे आप उपयोग कर सकते हैं कुंजी के रूप में संलग्न करना

A = ones(Int, 4, 4)
v = ones(100)
@info "Some variables"  A  s=sum(v)

# output
┌ Info: Some variables
│   A =
│    4×4 Array{Int64,2}:
│     1  1  1  1
│     1  1  1  1
│     1  1  1  1
│     1  1  1  1
â””   s = 100.0

लॉगिंग मैक्रोज़ के सभी @debug , @info , @warn और @error सामान्य विशेषताओं को साझा करते हैं जिन्हें अधिक सामान्य मैक्रो @logmsg लिए प्रलेखन में विस्तार से वर्णित किया गया है।

लॉग संरचना

प्रत्येक ईवेंट डेटा के कई टुकड़े उत्पन्न करता है, कुछ उपयोगकर्ता द्वारा प्रदान किए जाते हैं और कुछ स्वचालित रूप से निकाले जाते हैं। आइए पहले उपयोगकर्ता द्वारा परिभाषित डेटा की जांच करें:

  • संदेश को लॉग करने के लिए लॉग स्तर एक व्यापक श्रेणी है जिसका उपयोग शुरुआती फ़िल्टरिंग के लिए किया जाता है। टाइप LogLevel कई मानक स्तर हैं; उपयोगकर्ता-परिभाषित स्तर भी संभव हैं।
    • अनुप्रयोग या मॉड्यूल डीबग करते समय उपयोगी जानकारी के लिए Debug उपयोग Debug । ये ईवेंट डिफ़ॉल्ट रूप से अक्षम हैं।
    • कार्यक्रम के सामान्य संचालन के बारे में उपयोगकर्ता को सूचित करने के लिए Info का उपयोग करें।
    • संभावित समस्या का पता चलने पर Warn उपयोग करें।
    • त्रुटियों की रिपोर्ट करने के लिए Error का उपयोग करें जहां कोड को पुनर्प्राप्त करने और जारी रखने के लिए पर्याप्त संदर्भ है। (जब कोड में पर्याप्त संदर्भ नहीं होता है, तो अपवाद या शुरुआती रिटर्न अधिक उपयुक्त होता है।)
  • संदेश घटना का वर्णन करने वाली एक वस्तु है। के रूप में संदेश के रूप में पारित कर दिया गया है। स्थापित लॉगर की प्रदर्शन क्षमताओं के अनुसार show(io,mime,obj) का उपयोग करके अन्य प्रकार प्रदर्शित किए जाएंगे।
  • वैकल्पिक कुंजी-मूल्य जोड़े मनमाने डेटा को प्रत्येक घटना में संलग्न करने की अनुमति देते हैं। कुछ कुंजियों के पारंपरिक अर्थ हैं जो किसी घटना की व्याख्या करने के तरीके को प्रभावित कर सकते हैं (देखें @logmsg )।

सिस्टम प्रत्येक घटना के लिए कुछ मानक जानकारी भी देता है:

  • वह module जिसमें लॉगिंग मैक्रो का विस्तार किया गया था।
  • file और line जहाँ लॉगिंग मैक्रो स्रोत कोड में होता है।
  • एक संदेश id जो प्रत्येक लॉगिंग मैक्रो इनवोकेशन के लिए अद्वितीय है। यह किसी घटना से जुड़ी जानकारी या क्रियाओं की कैशिंग के लिए बहुत उपयोगी है। उदाहरण के लिए, उपयोगकर्ता को एक संदेश प्रस्तुत किए जाने की संख्या को सीमित करने के लिए इसका उपयोग किया जा सकता है।
  • घटना के लिए एक group , जो फ़ाइल के आधार नाम पर डिफ़ॉल्ट रूप से, बिना एक्सटेंशन के सेट है। यह लॉग स्तर की तुलना में अधिक सूक्ष्मता से संदेश समूहों में समूह के लिए इस्तेमाल किया जा सकता है (उदाहरण के लिए, सभी :depwarn चेतावनियों में समूह है :depwarn ), या मॉड्यूल के भीतर या भीतर तार्किक समूहों में।

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

लॉग इवेंट संसाधित करना

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

  • लॉग ईवेंट बनाना मॉड्यूल लेखक की चिंता है, जिसे यह तय करने की आवश्यकता है कि घटनाओं को कहां ट्रिगर किया जाए और कौन सी जानकारी शामिल की जाए।
  • लॉग ईवेंट्स की प्रोसेसिंग - यानी, डिस्प्ले, फ़िल्टरिंग, एग्रीगेशन और रिकॉर्डिंग - एप्लीकेशन लेखक की चिंता है, जिन्हें कई मॉड्यूल को एक सहयोगी एप्लिकेशन में एक साथ लाने की आवश्यकता होती है।

वालों

घटनाओं का प्रसंस्करण एक लकड़हारा द्वारा किया जाता है, जो घटना को देखने के लिए उपयोगकर्ता कॉन्फ़िगर करने योग्य कोड का पहला टुकड़ा है। सभी लकड़हारा AbstractLogger उपप्रकार होना चाहिए।

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

वैश्विक लकड़हारा global_logger साथ सेट किया जा सकता है, और कार्य-स्थानीय लॉगर्स with_logger का उपयोग करके नियंत्रित किया जा with_logger । नव स्पंदित कार्य मूल कार्य के लकड़हारे को विरासत में मिलते हैं।

पुस्तकालय द्वारा प्रदान किए गए तीन लकड़हारे प्रकार हैं। ConsoleLogger डिफ़ॉल्ट लकड़हारा है जिसे आप REPL शुरू करते समय देखते हैं। यह एक पठनीय पाठ प्रारूप में घटनाओं को प्रदर्शित करता है और प्रारूपण और फ़िल्टरिंग पर सरल लेकिन उपयोगकर्ता के अनुकूल नियंत्रण देने की कोशिश करता है। NullLogger जहां आवश्यक हो, सभी संदेशों को छोड़ने का एक सुविधाजनक तरीका है; यह devnull स्ट्रीम के बराबर है। SimpleLogger एक बहुत ही सरल पाठ स्वरूपण लकड़हारा है, मुख्य रूप से लॉगिंग सिस्टम को डीबग करने के लिए मुख्य रूप से उपयोगी है।

कस्टम लॉगर्स को संदर्भ अनुभाग में वर्णित कार्यों के लिए ओवरलोड के साथ आना चाहिए।

प्रारंभिक फ़िल्टरिंग और संदेश हैंडलिंग

जब कोई घटना होती है, तो आरंभिक फ़िल्टरिंग के कुछ चरण ऐसे संदेश उत्पन्न करने से बचने के लिए होते हैं जिन्हें त्याग दिया जाएगा:

  1. संदेश लॉग स्तर को एक वैश्विक न्यूनतम स्तर के खिलाफ जांचा जाता है ( disable_logging माध्यम से सेट)। यह एक क्रूड लेकिन बेहद सस्ती वैश्विक सेटिंग है।
  2. वर्तमान लकड़हारा राज्य को देखा जाता है और लॉगिंग के कैश्ड न्यूनतम स्तर के खिलाफ संदेश स्तर की जाँच की जाती है, जैसा कि Logging.min_enabled_level को कॉल करके पाया जाता है। यह व्यवहार पर्यावरण चर (इस पर बाद में) के माध्यम से ओवरराइड किया जा सकता है।
  3. Logging.shouldlog फ़ंक्शन को वर्तमान लकड़हारे के साथ कहा जाता है, कुछ न्यूनतम जानकारी (स्तर, मॉड्यूल, समूह, आईडी) ले रहा है, जिसे सांख्यिकीय रूप से गणना की जा सकती है। सबसे अधिक उपयोगी है, shouldlog को एक इवेंट id किया जाता है, जिसका उपयोग कैश्ड प्रेडिकेट के आधार पर घटनाओं को जल्दी से छोड़ने के लिए किया जा सकता है।

यदि ये सभी चेक पास हो जाते हैं, तो संदेश और की-वैल्यू पेयर का पूर्ण रूप से मूल्यांकन किया जाता है और Logging.handle_message फ़ंक्शन के माध्यम से वर्तमान लॉगर को पास किया जाता है। handle_message() आवश्यकतानुसार अतिरिक्त फ़िल्टरिंग कर सकता है और ईवेंट को स्क्रीन पर प्रदर्शित कर सकता है, इसे फ़ाइल में सहेज सकता है, आदि।

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

लॉग घटनाओं का परीक्षण

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

पर्यावरण चर

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

$ JULIA_DEBUG=loading julia -e 'using OhMyREPL'
┌ Debug: Rejecting cache file /home/user/.julia/compiled/v0.7/OhMyREPL.ji due to it containing an invalid cache header
â”” @ Base loading.jl:1328
[ Info: Recompiling stale cache file /home/user/.julia/compiled/v0.7/OhMyREPL.ji for module OhMyREPL
┌ Debug: Rejecting cache file /home/user/.julia/compiled/v0.7/Tokenize.ji due to it containing an invalid cache header
â”” @ Base loading.jl:1328
...

इसी तरह, पर्यावरण चर का उपयोग मॉड्यूल के डीबग लॉगिंग को सक्षम करने के लिए किया जा सकता है, जैसे कि Pkg , या मॉड्यूल रूट ( Base.moduleroot ) देखें। सभी डीबग लॉगिंग को सक्षम करने के लिए, सभी विशेष मान का उपयोग करें।

फ़ाइल में लॉग ईवेंट लिखना

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

# Load the logging module
julia> using Logging

# Open a textfile for writing
julia> io = open("log.txt", "w+")
IOStream(<file log.txt>)

# Create a simple logger
julia> logger = SimpleLogger(io)
SimpleLogger(IOStream(<file log.txt>), Info, Dict{Any,Int64}())

# Log a task-specific message
julia> with_logger(logger) do
           @info("a context specific log message")
       end

# Write all buffered messages to the file
julia> flush(io)

# Set the global logger to logger
julia> global_logger(logger)
SimpleLogger(IOStream(<file log.txt>), Info, Dict{Any,Int64}())

# This message will now also be written to the file
julia> @info("a global log message")

# Close the file
julia> close(io)

संदर्भ

घटनाएँ बनाना

[email protected] मैक्रो

@debug message  [key=value | value ...]
@info  message  [key=value | value ...]
@warn  message  [key=value | value ...]
@error message  [key=value | value ...]

@logmsg level message [key=value | value ...]

एक सूचना message साथ एक लॉग रिकॉर्ड बनाएँ। सुविधा के लिए, चार लॉगिंग मैक्रोज़ @debug , @info , @warn और @error को परिभाषित किया गया है जो मानक गंभीरता के स्तर पर Debug , Info , Warn और Error लॉग करते हैं। @logmsg level को किसी LogLevel या कस्टम लॉग स्तर प्रकार के लिए प्रोग्रामेटिक रूप से सेट करने की अनुमति देता level

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

key=value युग्मों की वैकल्पिक सूची मनमाने ढंग से परिभाषित उपयोगकर्ता मेटाडेटा का समर्थन करती है जो लॉग रिकॉर्ड के भाग के रूप में लॉगिंग बैकएंड से होकर गुजरेगी। यदि केवल एक value अभिव्यक्ति की आपूर्ति की जाती है, तो Symbol का उपयोग करके अभिव्यक्ति का प्रतिनिधित्व करने वाली एक कुंजी उत्पन्न होगी। उदाहरण के लिए, x x=x x बन जाता है, और foo(10) Symbol("foo(10)")=foo(10) बन जाता है Symbol("foo(10)")=foo(10) । मुख्य मूल्य युग्मों की एक सूची को अलग करने के लिए, सामान्य splatting syntax, @info "blah" kws... उपयोग करें @info "blah" kws...

कुछ कुंजी हैं जो स्वचालित रूप से उत्पन्न लॉग डेटा को ओवरराइड करने की अनुमति देते हैं:

  • संदेश के स्रोत स्थान से एक अलग मूल मॉड्यूल निर्दिष्ट करने के लिए _module=mod का उपयोग किया जा सकता है।
  • _group=symbol संदेश समूह को ओवरराइड करने के लिए _group=symbol का उपयोग किया जा सकता है (यह आमतौर पर स्रोत फ़ाइल के आधार नाम से लिया गया है)।
  • _id=symbol स्वचालित रूप से उत्पन्न अद्वितीय संदेश पहचानकर्ता को ओवरराइड करने के लिए _id=symbol का उपयोग किया जा सकता है। यह उपयोगी है अगर आपको अलग-अलग स्रोत लाइनों पर उत्पन्न संदेशों को बहुत बारीकी से जोड़ने की आवश्यकता है।
  • _file=string और _line=integer का उपयोग लॉग संदेश के स्पष्ट स्रोत स्थान को ओवरराइड करने के लिए किया जा सकता है।

कुछ प्रमुख मूल्य जोड़े भी हैं जिनका पारंपरिक अर्थ है:

  • maxlog=integer बैकएंड के संकेत के रूप में उपयोग किया जाना चाहिए कि संदेश को अधिक से अधिक बार प्रदर्शित किया जाना चाहिए।
  • exception=ex का उपयोग लॉग संदेश के साथ अपवाद का परिवहन करने के लिए किया जाना चाहिए, जिसका उपयोग अक्सर @error साथ किया जाता है। एक संबंधित बैकट्रेस bt टुपल exception=(ex,bt) का उपयोग करके संलग्न किया जा सकता है।

उदाहरण

@debug "Verbose debugging information.  Invisible by default"
@info  "An informational message"
@warn  "Something was odd.  You should pay attention"
@error "A non fatal error occurred"

x = 10
@info "Some variables attached to the message" x a=42.0

@debug begin
    sA = sum(A)
    "sum(A) = $sA is an expensive operation, evaluated only when `shouldlog` returns true"
end

for i=1:10000
    @info "With the default backend, you will only see (i = $i) ten times"  maxlog=10
    @debug "Algorithm1" i progress=i/10000
end
source

Base.CoreLogging.LogLevel प्रकार

LogLevel(level)

एक लॉग रिकॉर्ड की गंभीरता / क्रियाशीलता।

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

source

AbstractLogger के साथ प्रसंस्करण की घटनाओं

इवेंट प्रोसेसिंग को AbstractLogger जुड़े कार्यों को ओवरराइड करके नियंत्रित किया जाता है:

लागू करने के तरीके संक्षिप्त विवरण
Logging.handle_message एक लॉग ईवेंट को संभालें
Logging.shouldlog घटनाओं को जल्दी छानना
Logging.min_enabled_level स्वीकृत घटनाओं के लॉग स्तर के लिए कम बाध्य
वैकल्पिक तरीके डिफ़ॉल्ट परिभाषा संक्षिप्त विवरण
Logging.catch_exceptions true घटना मूल्यांकन के दौरान अपवादों को पकड़ें

Base.CoreLogging.AbstractLogger प्रकार

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

source

Base.CoreLogging.handle_message फ़ंक्शन

handle_message(logger, level, message, _module, group, id, file, line; key1=val1, ...)

level पर logger को संदेश logger । तार्किक स्थान जिस पर संदेश उत्पन्न किया गया था, मॉड्यूल _module और group द्वारा दिया गया है; file और line द्वारा स्रोत स्थान। id एक मनमाना अनोखा Symbol है जिसे फ़िल्टर करते समय लॉग स्टेटमेंट की पहचान करने के लिए एक कुंजी के रूप में उपयोग किया जाता है।

source

Base.CoreLogging.shouldlog फ़ंक्शन

shouldlog(logger, level, _module, group, id)

जब logger level पर मैसेज स्वीकार करता है, तो उसे वापस लौटाएं।

source

Base.CoreLogging.min_enabled_level फ़ंक्शन

min_enabled_level(logger)

शुरुआती फ़िल्टरिंग के लिए logger लिए अधिकतम अक्षम स्तर लौटाएं। अर्थात, नीचे का लॉग स्तर या जिसके बराबर सभी संदेश फ़िल्टर किए जाते हैं।

source

Base.CoreLogging.catch_exceptions फ़ंक्शन

catch_exceptions(logger)

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

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

यदि आप एक ऑडिट ट्रेल के रूप में लॉगिंग का उपयोग करना चाहते हैं, तो आपको इसे अपने लकड़हारे प्रकार के लिए अक्षम करना चाहिए।

source

Base.CoreLogging.disable_logging फ़ंक्शन

disable_logging(level)

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

source

लॉगर्स का उपयोग करना

लकड़हारा स्थापना और निरीक्षण:

Base.CoreLogging.global_logger फ़ंक्शन

global_logger()

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

global_logger(logger)

वैश्विक लकड़हारे को logger सेट करें, और पिछले वैश्विक लकड़हारे को वापस करें।

source

Base.CoreLogging.with_logger फ़ंक्शन

with_logger(function, logger)

function निष्पादित function , logger को सभी लॉग संदेश निर्देशित करें।

उदाहरण

function test(x)
    @info "x = $x"
end

with_logger(logger) do
    test(1)
    test([1,2])
end
source

Base.CoreLogging.current_logger फ़ंक्शन

current_logger()

वर्तमान कार्य के लिए लकड़हारा लौटें, या वैश्विक लकड़हारा यदि कोई भी कार्य से जुड़ा नहीं है।

source

लॉगर जो सिस्टम के साथ दिए गए हैं:

Base.CoreLogging.NullLogger प्रकार

NullLogger()

लकड़हारा जो सभी संदेशों को निष्क्रिय कर देता है और कोई आउटपुट नहीं देता है - लकड़हारा / देव / शून्य के बराबर।

source

Logging.ConsoleLogger प्रकार

ConsoleLogger(stream=stderr, min_level=Info; meta_formatter=default_metafmt,
              show_limited=true, right_justify=0)

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

min_level से कम लॉग स्तर फ़िल्टर किए जाते हैं।

कीवर्ड तर्क सेट करके संदेश स्वरूपण को नियंत्रित किया जा सकता है:

  • meta_formatter एक फ़ंक्शन है जो लॉग ईवेंट मेटाडेटा (level, _module, group, id, file, line) लेता है और एक रंग देता है (जैसा कि प्रिंटस्टाइल में पास किया जाएगा), उपसर्ग और लॉग संदेश के लिए प्रत्यय। डिफ़ॉल्ट लॉग स्तर और मॉड्यूल, फ़ाइल और लाइन स्थान वाले प्रत्यय के साथ उपसर्ग करना है।
  • show_limited बड़े डेटा स्ट्रक्चर्स की छपाई को सीमित करता है, जो कि सेटिंग द्वारा स्क्रीन पर फिट हो सकता है :limit स्वरूपण के लिए IOContext कुंजी को :limit करें।
  • right_justify पूर्णांक स्तंभ है जो लॉग मेटाडेटा सही है पर सही है। डिफ़ॉल्ट शून्य है (मेटाडेटा अपनी लाइन पर चला जाता है)।
source

Base.CoreLogging.SimpleLogger प्रकार

SimpleLogger(stream=stderr, min_level=Info)

stream करने के लिए min_level बराबर या उससे अधिक स्तर वाले सभी संदेशों को लॉग करने के लिए सरलीकृत लकड़हारा।

source