लॉगिंग: काय, कसे, कुठे आणि कशासह?

कोडजिम समुदायातील सर्वांना नमस्कार! आज लॉगिंगबद्दल बोलूया:

1. ते काय आहे, ते का अस्तित्वात आहे, तुम्ही ते कधी वापरावे, कधी टाळावे.
2. Java मध्ये कोणती लॉगिंग अंमलबजावणी उपलब्ध आहे आणि आपण या सर्व लॉगिंग पर्यायांसह काय करावे.
आणि लॉग स्तर. आम्ही परिशिष्ट काय आहे आणि ते योग्यरित्या कसे कॉन्फिगर करावे याबद्दल चर्चा करू.
3. लॉगिंग नोड्स आणि त्यांना योग्यरित्या कसे कॉन्फिगर करावे जेणेकरून सर्वकाही आम्हाला पाहिजे तसे कार्य करेल.

ही सामग्री विस्तृत प्रेक्षकांसाठी आहे. जावा जाणून घेतल्याने कोणालाही हे स्पष्ट होईल, तसेच जे लोक आधीपासून काम करत आहेत परंतु त्यांनी फक्त एक्सप्लोर केले आहे logger.info("log something"); चला जाऊया!

तुम्हाला लॉगिंगची गरज का आहे?

चला काही वास्तविक प्रकरणे पाहू ज्यात लॉगिंग समस्या सोडवू शकते. माझ्या कामातील एक उदाहरण येथे आहे. असे काही मुद्दे आहेत जेथे अनुप्रयोग इतर सेवांसह एकत्रित होतो. मी एक प्रकारचा "अलिबी" स्थापित करण्यासाठी या बिंदूंवर लॉगिंग वापरतो : जर एकत्रीकरण कार्य करत नसेल, तर कोणत्या बाजूने समस्या आहे हे शोधणे सोपे होते. डेटाबेसमध्ये साठवलेली महत्त्वाची माहिती लॉग करणे देखील इष्ट आहे. उदाहरणार्थ, प्रशासक वापरकर्त्याची निर्मिती. ही तंतोतंत अशा प्रकारची आहे जी लॉग करणे चांगले होईल.

Java मध्ये लॉग इन करण्यासाठी साधने

Java मधील सुप्रसिद्ध लॉगिंग उपायांपैकी, आम्ही खालील गोष्टी हायलाइट करू शकतो:

• Log4j
• JUL — java.util.logging
• JCL — जकार्ता कॉमन्स लॉगिंग
• लॉगबॅक
• SLF4J — Java साठी साधे लॉगिंग दर्शनी भाग

System.err.println

सुरुवातीला, System.err.println (कन्सोलवर लॉग नोंदी प्रदर्शित करणे) होते. आजही, हे तंत्र डीबग करताना द्रुतपणे लॉग करण्यासाठी वापरले जाते. अर्थात, येथे चर्चा करण्यासाठी कोणत्याही सेटिंग्ज नाहीत, म्हणून फक्त ही पद्धत लक्षात ठेवा आणि आम्ही पुढे जाऊ.

Log4j

हे एक संपूर्ण समाधान आहे जे विकसकांनी आवश्यकतेनुसार तयार केले आहे. परिणाम खरोखर एक मनोरंजक साधन आहे जे आपण वापरू शकता. विविध परिस्थितींमुळे, हे समाधान JDK मध्ये संपले नाही, ही वस्तुस्थिती आहे जी संपूर्ण समुदायाला खूप अस्वस्थ करते. Log4j मध्ये कॉन्फिगरेशन पर्याय आहेत जे तुम्हाला पॅकेजमध्ये लॉगिंग सक्षम करू देतात com.example.typeआणि सबपॅकेजमध्ये ते बंद करू शकतात com.example.type.generic. यामुळे लॉग इन करणे आवश्यक नसलेले कोड द्रुतपणे वगळणे शक्य होते. येथे हे लक्षात घेणे महत्त्वाचे आहे की Log4j च्या दोन आवृत्त्या आहेत: 1.2.x आणि 2.xx, आणि त्या एकमेकांशी विसंगत आहेत . Log4j ने परिशिष्टाची संकल्पना जोडली(लॉग लिहिण्यासाठी वापरले जाणारे साधन) आणि लेआउट (लॉग फॉरमॅटिंग). हे आपल्याला फक्त आपल्याला आवश्यक ते लॉग करू देते आणि आपल्याला आवश्यकतेनुसार लॉग करू देते. आम्ही थोड्या वेळाने परिशिष्ट बद्दल अधिक बोलू.

JUL — java.util.logging

या सोल्यूशनचा एक महत्त्वाचा फायदा म्हणजे JUL JDK (Java Development Kit) मध्ये समाविष्ट आहे. दुर्दैवाने, जेव्हा ते विकसित केले गेले, तेव्हा त्याच्या निर्मात्यांनी ते लोकप्रिय Log4j युटिलिटीवर आधारित नाही, तर IBM कडून एक उपाय आहे. त्या निर्णयाचे परिणाम झाले आहेत. वास्तविकता अशी आहे की आता कोणीही JUL वापरत नाही. JUL मधील लॉग स्तर लॉगबॅक, Log4j आणि Slf4j पेक्षा भिन्न आहेत. यामुळे त्यांना एकमेकांना समजून घेणे कठीण होते. लॉगर तयार करणे कमी-अधिक समान आहे. हे करण्यासाठी, आपण एक आयात करणे आवश्यक आहे:

java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggingJul.class.getName());

वर्गाचे नाव उत्तीर्ण झाले आहे, त्यामुळे आमचे लॉगिंग कोठून येईल हे आम्हाला माहित आहे. Java 8 ने सुरुवात करून, तुम्ही पास करू शकता Supplier<String>. हे आम्हाला वाचण्यात आणि एक ओळ तयार करण्यात मदत करते जेव्हा आम्हाला त्याची खरोखर गरज असते, प्रत्येक वेळी, पूर्वीप्रमाणेच. फक्त Java 8 च्या रिलीझसह विकासकांनी शेवटी महत्त्वाच्या समस्यांचे निराकरण केले आणि JUL खरोखर वापरण्यायोग्य बनवले. बहुदा, पॅरामीटरसह पद्धती Supplier<String> msgSupplier, खाली दर्शविल्याप्रमाणे:

public void info(Supplier<String> msgSupplier) {
   log(Level.INFO, msgSupplier);
}

JCL — जकार्ता कॉमन्स लॉगिंग

बर्याच काळापासून लॉगिंगसाठी कोणतेही उद्योग मानक नसल्यामुळे आणि अनेक लोकांनी त्यांचे स्वतःचे सानुकूल लॉगर तयार केले होते, जेसीएल सोडण्याचा निर्णय घेण्यात आला, एक सामान्य रॅपर जो इतरांच्या वर वापरला जाऊ शकतो. का? काहीवेळा प्रकल्पामध्ये जोडलेल्या अवलंबनांमध्ये प्रकल्पातील एकापेक्षा वेगळा लॉगर वापरला जातो. यामुळे, ते प्रकल्पात संक्रमणात्मक अवलंबित्व म्हणून जोडले गेले आणि हे सर्व एकत्र ठेवण्याचा प्रयत्न करताना वास्तविक समस्या निर्माण झाल्या. दुर्दैवाने, आवरण फार कार्यक्षम नव्हते आणि काहीही जोडले नाही. प्रत्येकाने JCL वापरल्यास ते सोयीचे होईल. पण तसे झाले नाही, त्यामुळे जेसीएल वापरणे ही सध्याची सर्वोत्तम कल्पना नाही.

लॉगबॅक

मुक्त-स्रोत मार्ग काटेरी आहे... Log4j लिहिलेल्या त्याच विकसकाने उत्तराधिकारी लॉगिंग फ्रेमवर्क म्हणून लॉगबॅक देखील लिहिले. हे Log4j सारख्याच कल्पनेवर आधारित होते. लॉगबॅकमधील फरक आहेत:

• सुधारित कामगिरी
• Slf4j साठी मूळ समर्थन जोडले
• विस्तारित फिल्टरिंग पर्याय

डीफॉल्टनुसार, लॉगबॅकला कोणत्याही कॉन्फिगरेशनची आवश्यकता नसते आणि सर्व इव्हेंट्स डीबग स्तरावर आणि उच्च पातळीवर रेकॉर्ड केले जातात. तुम्हाला काही सानुकूलनाची आवश्यकता असल्यास, तुम्ही ते XML कॉन्फिगरेशनद्वारे प्राप्त करू शकता:

<configuration>
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>app.log</file>
        <encoder>
            <pattern>%d{HH:mm:ss,SSS} %-5p [%c] - %m%n</pattern>
        </encoder>
    </appender>
    <logger name="org.hibernate.SQL" level="DEBUG" />
    <logger name="org.hibernate.type.descriptor.sql" level="TRACE" />
    <root level="info">
        <appender-ref ref="FILE" />
    </root>
</configuration>

SLF4J — Java साठी साधे लॉगिंग दर्शनी भाग

2006 मध्ये कधीतरी, Log4j च्या संस्थापकांपैकी एकाने प्रकल्प सोडला आणि Slf4j (जावासाठी सिंपल लॉगिंग फॅकेड), Log4j, JUL, कॉमन-लॉगिंग आणि लॉगबॅकसाठी एक आवरण तयार केले. तुम्ही बघू शकता, आम्ही रॅपरवर रॅपर तयार करण्याच्या टप्प्यावर पोहोचलो आहोत... या प्रकरणात, ते दोन भागांमध्ये विभागले गेले आहे: एक API जो अनुप्रयोगात वापरला जातो आणि एक अंमलबजावणी जो वेगळ्यासह जोडला जातो. प्रत्येक प्रकारच्या लॉगिंगसाठी अवलंबित्व. उदाहरणार्थ, slf4j-log4j12.jarआणि slf4j-jdk14.jar. आपल्याला योग्य अंमलबजावणी करणे आवश्यक आहे आणि तेच आहे: आपला संपूर्ण प्रकल्प त्याचा वापर करेल. Slf4j सर्व नवीनतम वैशिष्ट्यांना समर्थन देते, जसे की लॉगिंगसाठी स्ट्रिंगचे स्वरूपन. पूर्वी, अशी समस्या होती. समजा आम्ही याप्रमाणे लॉग एंट्री तयार करतो:

log.debug("User " + user + " connected from " + request.getRemoteAddr());

कॉन्कटेनेशन ऑपरेटरमुळे, userऑब्जेक्ट शांतपणे स्ट्रिंग बनते धन्यवाद user.toString(). यास वेळ लागतो आणि प्रणालीची गती कमी होते. आणि आम्ही अनुप्रयोग डीबग करत असल्यास ते ठीक असू शकते. या वर्गासाठी लॉग लेव्हल INFO किंवा त्याहून अधिक असल्यास आम्हाला समस्या येऊ लागतात. दुसऱ्या शब्दांत, आम्ही ही लॉग एंट्री (INFO किंवा उच्चसाठी) लिहू नये आणि आम्ही स्ट्रिंग जोडणी वापरू नये. सिद्धांततः, लॉगिंग लायब्ररीनेच याकडे लक्ष दिले पाहिजे. जसे घडते तसे, Log4j च्या पहिल्या आवृत्तीमध्ये ही सर्वात मोठी समस्या असल्याचे दिसून आले. हे एक सभ्य समाधान वितरीत केले नाही, परंतु त्याऐवजी असे काहीतरी करण्याचे सुचवले:

if (log.isDebugEnabled()) {
    log.debug("User " + user + " connected from " + request.getRemoteAddr());
}

म्हणजेच, लॉगिंगसाठी एका ओळीच्या कोडऐवजी, त्यांनी 3 लिहिण्याची सूचना केली! लॉगिंगने कोड बदल कमी केला पाहिजे आणि तीन ओळी स्पष्टपणे त्या सामान्य दृष्टिकोनाचे उल्लंघन करतात. Slf4j मध्ये JDK आणि API सह सुसंगतता समस्या नव्हती, म्हणून लगेचच एक छान उपाय समोर आला:

log.debug("User {} connected from {}", user, request.getRemoteAddr());

जेथे {}मेथडला पास केलेल्या वितर्कांसाठी प्लेसहोल्डर सूचित करते. म्हणजेच, पहिला , आणि दुसरा शी संबंधित {}आहे . असे केल्याने, लॉग लेव्हलला आम्हाला लॉग एंट्री लिहिण्याची आवश्यकता असेल तरच आम्ही स्ट्रिंग जोडणी करू. त्यानंतर, Sjf4j वेगाने लोकप्रियता वाढू लागली. सध्या, तो सर्वोत्तम उपाय आहे. त्यानुसार, बाइंडिंग वापरून लॉगिंगवर एक नजर टाकूया . user{}request.getRemoteAddr()slf4j-log4j12

काय लॉग करणे आवश्यक आहे

नक्कीच, आपण सर्वकाही लॉग करू नये. हे सहसा आवश्यक नसते आणि कधीकधी धोकादायक देखील असते. उदाहरणार्थ, जर तुम्ही एखाद्याचा वैयक्तिक डेटा लॉग केला आणि तो कसा तरी लीक झाला, तर खर्‍या समस्या असतील, विशेषत: पाश्चात्य बाजारपेठांवर केंद्रित प्रकल्पांमध्ये. परंतु अशा काही गोष्टी आहेत ज्या आपण निश्चितपणे लॉग केल्या पाहिजेत :

1. अर्जाचा प्रारंभ/शेवट. अनुप्रयोग खरोखरच अपेक्षेप्रमाणे सुरू झाला आणि संपला की नाही हे जाणून घेणे आवश्यक आहे.
2. सुरक्षा समस्या. येथे एखाद्याच्या पासवर्डचा अंदाज लावण्याचे प्रयत्न लॉग इन करणे, प्रशासकांनी साइन इन केल्याची उदाहरणे इ.
3. काही अर्जाची स्थिती . उदाहरणार्थ, व्यवसाय प्रक्रियेत एका राज्यातून दुसऱ्या राज्यात संक्रमण.
4. संबंधित लॉग स्तरासह काही डीबग माहिती .
5. काही SQL स्क्रिप्ट. जेव्हा हे आवश्यक असते तेव्हा वास्तविक-जगातील प्रकरणे असतात. परंतु पुन्हा, लॉग पातळी कुशलतेने समायोजित करून, आपण उत्कृष्ट परिणाम प्राप्त करू शकता.
6. रनिंग थ्रेड्स गोष्टी योग्यरित्या कार्य करत आहेत हे सत्यापित करताना लॉग केले जाऊ शकतात.

लॉगिंगमध्ये लोकप्रिय त्रुटी

येथे अनेक बारकावे आहेत, परंतु आम्ही काही सामान्य चुकांचा विशेष उल्लेख करू:

1. अत्यधिक लॉगिंग. सैद्धांतिकदृष्ट्या महत्त्वाची असू शकणारी प्रत्येक पायरी तुम्ही लॉग करू नये. येथे एक चांगला नियम आहे: लॉग लोडच्या 10% पेक्षा जास्त नसावेत. अन्यथा, कार्यप्रदर्शन समस्या असतील.
2. सर्व डेटा एका फाईलमध्ये लॉग करत आहे. काही क्षणी, यामुळे लॉग वाचणे/लिहणे खूप कठीण होईल, काही प्रणालींना फाइल आकारावर मर्यादा आहेत हे नमूद करू नका.
3. चुकीचे लॉग स्तर वापरणे. प्रत्येक लॉग स्तरावर स्पष्ट सीमा आहेत आणि त्यांचा आदर केला पाहिजे. सीमा अस्पष्ट असल्यास, कोणती पातळी वापरायची याबद्दल तुम्ही करार करू शकता.

लॉग पातळी

लॉग स्तर काय आहेत? लॉग एंट्रीजची पदानुक्रम तयार करण्यासाठी, काही नियम आणि सीमांकन आवश्यक आहेत. म्हणूनच लॉग स्तर सादर केले गेले. अनुप्रयोगामध्ये स्तर सेट केला आहे. जर एखादी नोंद निर्दिष्ट पातळीपेक्षा कमी असेल तर ती लॉग केली जात नाही. उदाहरणार्थ, आमच्याकडे लॉग आहेत जे आम्ही अनुप्रयोग डीबग करताना वापरतो. सामान्य ऑपरेशन दरम्यान (जेव्हा अनुप्रयोग त्याच्या हेतूसाठी वापरला जातो), अशा लॉगची आवश्यकता नसते. म्हणून, लॉग पातळी डीबगिंगपेक्षा जास्त आहे. Log4j वापरून लॉग लेव्हल्स पाहू. JUL व्यतिरिक्त, इतर उपाय समान लॉग स्तर वापरतात. येथे ते कमी क्रमाने आहेत:

• बंद: कोणत्याही लॉग एंट्री रेकॉर्ड केल्या जात नाहीत; सर्व काही दुर्लक्षित आहे.
• घातक: एक त्रुटी जी अनुप्रयोगास चालू ठेवण्यापासून प्रतिबंधित करते. उदाहरणार्थ, "JVM आउट ऑफ मेमरी त्रुटी".
• त्रुटी: या स्तरावरील त्रुटी त्या समस्या दर्शवतात ज्यांचे निराकरण करणे आवश्यक आहे. त्रुटी संपूर्णपणे अनुप्रयोग थांबवत नाही. इतर विनंत्या योग्यरित्या कार्य करू शकतात.
• चेतावणी: चेतावणी दर्शवणार्‍या लॉग नोंदी. काहीतरी अनपेक्षित घडले, परंतु सिस्टमने सामना करण्यास सक्षम होते आणि विनंती पूर्ण केली
• माहिती: अनुप्रयोगातील महत्त्वाच्या क्रिया दर्शविणाऱ्या लॉग एंट्री. या चुका किंवा इशारे नाहीत. ते अपेक्षित सिस्टम इव्हेंट आहेत.
• डीबग: अनुप्रयोग डीबग करण्यासाठी लॉग नोंदी आवश्यक आहेत. ॲप्लिकेशन अपेक्षेप्रमाणेच करतो याची खात्री करण्यासाठी किंवा ऍप्लिकेशनने केलेल्या कृतींचे वर्णन करण्यासाठी, म्हणजे "Entered method1".
• ट्रेस: ​​डीबगिंगसाठी निम्न-प्राधान्य लॉग एंट्री. सर्वात कमी लॉग स्तर.
• सर्व: अनुप्रयोगाच्या सर्व लॉग नोंदी लिहिण्यासाठी लॉग स्तर.

ऍप्लिकेशनमध्ये कुठेतरी INFO लॉग स्तर सक्षम केला जातो, नंतर प्रत्येक स्तरासाठी INFO पासून FATAL पर्यंतच्या नोंदी लॉग केल्या जातील. जर FATAL लॉग स्तर सेट केला असेल, तर फक्त त्या पातळीसह लॉग नोंदी लिहिल्या जातील.

लॉगिंग आणि लॉग पाठवणे: परिशिष्ट

लॉग4j वापरताना हे सर्व कसे कार्य करते याचा विचार करूया, जे लॉग लिहिण्यासाठी/पाठवण्याच्या भरपूर संधी प्रदान करते:

• फाईलवर लिहिण्यासाठी -DailyRollingFileAppender
• कन्सोलवर माहिती लिहिण्यासाठी -ConsoleAppender
• डेटाबेसवर लॉग लिहिण्यासाठी —JDBCAppender
• TCP/IP वर लॉग पाठवणे व्यवस्थापित करण्यासाठी —TelnetAppender
• लॉगिंग कार्यक्षमतेवर नकारात्मक परिणाम करत नाही याची खात्री करण्यासाठी -AsyncAppender

आणखी काही अंमलबजावणी आहेत: संपूर्ण यादी येथे उपलब्ध आहे . तसे, जर आपल्याला आवश्यक असलेले परिशिष्ट अस्तित्वात नसेल, तर काही हरकत नाही. Log4j सपोर्ट करत असलेल्या Appender इंटरफेसची अंमलबजावणी करून तुम्ही तुमचा स्वतःचा एपेंडर लिहू शकता .

लॉगिंग नोड्स

प्रात्यक्षिक हेतूंसाठी, आम्ही Slf4j इंटरफेसचा वापर करू, Log4j कडून अंमलबजावणीसह. लॉगर तयार करणे खूप सोपे आहे: नावाच्या वर्गात MainDemo, जे काही लॉगिंग करेल, आम्हाला खालील जोडणे आवश्यक आहे:

org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(MainDemo.class);

हे आमच्यासाठी एक लॉगर तयार करेल. लॉग एंट्री करण्यासाठी, अनेक उपलब्ध पद्धती आहेत ज्यांची नावे कोणती लॉग पातळी वापरली जाईल हे दर्शवितात. उदाहरणार्थ:

logger.trace("Method 1 started with argument={}", argument);
logger.debug("Database updated with script = {}", script);
logger.info("Application has started on port = {}", port);
logger.warn("Log4j didn't find the log4j.properties file. Please fix this.");
logger.error("Connection refused to host = {}", host);

आम्ही वर्ग उत्तीर्ण करत असलो तरी, अंतिम नाव हे पॅकेजसह वर्गाचे पूर्ण नाव आहे. हे केले जाते जेणेकरून नंतर तुम्ही लॉगिंगला नोड्समध्ये विभाजित करू शकता आणि प्रत्येक नोडसाठी लॉगिंग स्तर आणि ऍपेंडर कॉन्फिगर करू शकता. उदाहरणार्थ, वर्गात लॉगर तयार केला होता com.github.romankh3.logginglecture.MainDemo. लॉगिंग नोड्सची पदानुक्रम तयार करण्यासाठी नाव आधार प्रदान करते. मुख्य नोड उच्च-स्तरीय रूटलॉगर आहे . हा नोड आहे जो संपूर्ण अनुप्रयोगासाठी सर्व लॉग प्रविष्ट्या प्राप्त करतो. उर्वरित नोड्स खाली दाखवल्याप्रमाणे चित्रित केले जाऊ शकतात: परिशिष्ट विशिष्ट लॉगिंग नोड्ससाठी कॉन्फिगर केले आहेत. आता आपण log4j.properties फाईल पाहणार आहोत ते कसे कॉन्फिगर करायचे याचे उदाहरण पाहण्यासाठी.

log4j.properties फाईलसाठी चरण-दर-चरण मार्गदर्शक

आम्ही सर्व काही एका वेळी एक पाऊल सेट करू आणि काय शक्य आहे ते पाहू:

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender

ही ओळ सांगते की आम्ही CONSOLE परिशिष्टाची नोंदणी करत आहोत, जे org.apache.log4j.ConsoleAppender अंमलबजावणी वापरते. हा परिशिष्ट कन्सोलवर माहिती लिहितो. पुढे, आम्ही दुसर्या परिशिष्टाची नोंदणी करतो. हे फाइलवर लिहेल:

log4j.appender.FILE=org.apache.log4j.RollingFileAppender

हे लक्षात घेणे महत्वाचे आहे की परिशिष्टांना अद्याप कॉन्फिगर करणे आवश्यक आहे. एकदा आम्ही आमचे परिशिष्ट नोंदणीकृत केल्यानंतर, आम्ही नोड्सवर कोणते लॉग स्तर आणि कोणते परिशिष्ट वापरले जातील हे निर्धारित करू शकतो.

log4j.rootLogger=DEBUG, CONSOLE, FILE

• log4j.rootLogger म्हणजे आम्ही रूट नोड कॉन्फिगर करत आहोत, ज्यामध्ये सर्व लॉग एंट्री आहेत
• समान चिन्हानंतरचा पहिला शब्द लिहिण्यासाठी किमान लॉग स्तर दर्शवतो (आमच्या बाबतीत, तो DEBUG आहे)
• स्वल्पविरामानंतर, आम्ही वापरण्यासाठी सर्व परिशिष्ट सूचित करतो.

अधिक विशिष्ट लॉगिंग नोड कॉन्फिगर करण्यासाठी, तुम्ही यासारखी एंट्री वापराल:

log4j.logger.com.github.romankh3.logginglecture=TRACE, OWN, CONSOLE

जेथे log4j.logger.विशिष्ट नोडचा संदर्भ देण्यासाठी वापरला जातो. आमच्या बाबतीत, com.github.romankh3.logginglecture. आता CONSOLE परिशिष्ट कॉन्फिगर करण्याबद्दल बोलूया:

# CONSOLE appender customization
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.threshold=DEBUG
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[%-5p] : %c:%L : %m%n

येथे आपण पाहतो की परिशिष्ट कोणत्या विशिष्ट स्तरावर कार्य करण्यास प्रारंभ करेल ते सेट करणे शक्य आहे. प्रत्यक्षात काय घडते याचे एक उदाहरण येथे आहे: समजा INFO पातळीसह संदेश लॉगिंग नोडद्वारे प्राप्त झाला आणि त्यास नियुक्त केलेल्या परिशिष्टाकडे पाठविला गेला. जर परिशिष्टाचा थ्रेशोल्ड WARN वर सेट केला असेल, तर तो लॉग एंट्री प्राप्त करतो परंतु त्याच्याशी काहीही करत नाही. पुढे, संदेश कोणता लेआउट वापरेल हे ठरवायचे आहे. मी उदाहरणात PatternLayout वापरतो, परंतु इतर अनेक पर्याय आहेत. आम्ही या लेखात त्यांना कव्हर करणार नाही. FILE परिशिष्ट कॉन्फिगर करण्याचे उदाहरण:

# File appender customization
log4j.appender.FILE=org.apache.log4j.RollingFileAppender
log4j.appender.FILE.File=./target/logging/logging.log
log4j.appender.FILE.MaxFileSize=1MB
log4j.appender.FILE.threshold=DEBUG
log4j.appender.FILE.MaxBackupIndex=2
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[ %-5p] - %c:%L - %m%n

तुम्ही विशिष्ट फाइल कॉन्फिगर करू शकता ज्यावर लॉग एंट्री लिहिल्या जातील, जसे की या ओळीतून पाहिले जाऊ शकते:

log4j.appender.FILE.File=./target/logging/logging.log

एंट्री फाईलवर लिहिली आहे logging.log. फाइल आकारासह समस्या टाळण्यासाठी, आपण कमाल कॉन्फिगर करू शकता, जे या प्रकरणात 1MB आहे. MaxBackupIndexअशा किती लॉग फाईल्स असतील ते सूचित करते. यापेक्षा जास्त फाईल्स तयार करायच्या असतील तर पहिली फाईल डिलीट केली जाईल. लॉगिंग कॉन्फिगर केलेले वास्तविक उदाहरण पाहण्यासाठी, तुम्ही GitHub वरील सार्वजनिक भांडारात जाऊ शकता .

आम्ही काय चर्चा केली ते मजबूत करा

आम्ही वर्णन केलेल्या प्रत्येक गोष्टीसाठी स्वतः प्रयत्न करा:

• वरील उदाहरणाप्रमाणे तुमचा स्वतःचा प्रकल्प तयार करा.
• जर तुम्हाला मावेन कसे वापरायचे हे माहित असेल तर ते वापरा. नसल्यास, हे ट्यूटोरियल वाचा, जे लायब्ररीला कसे जोडायचे याचे वर्णन करते.

सारांश

1. आम्ही Java मध्ये अस्तित्वात असलेल्या लॉगिंग सोल्यूशन्सबद्दल बोललो.
2. जवळजवळ सर्व सुप्रसिद्ध लॉगिंग लायब्ररी एका व्यक्तीने लिहिलेल्या होत्या :D
3. आम्ही काय लॉग केले पाहिजे आणि काय करू नये हे शिकलो.
4. आम्ही लॉग स्तर शोधून काढले.
5. आमची लॉगिंग नोड्सशी ओळख झाली.
6. आम्ही परिशिष्ट काय आहे आणि ते कशासाठी आहे ते पाहिले.
7. आम्ही चरण-दर-चरण log4j.proterties फाइल तयार केली.

अतिरिक्त साहित्य

1. कोडजिम: लॉगर धडा
2. Weekly Geekly: Java लॉगिंग. नमस्कार जग
3. कोडिंग हॉरर: लॉगिंगसह समस्या
4. YouTube: जावा लॉगिंग हेल समजून घेणे - मूलभूत गोष्टी. जावा लॉगिंग हेल आणि त्यातून कसे बाहेर राहायचे
5. Log4j: परिशिष्ट
6. Log4j: लेआउट

माझा दुसरा लेख देखील पहा:

• IntelliJ IDEA मध्ये डीबगिंग: एक नवशिक्या मार्गदर्शक