जावा / लॉगबैक में अलग विधि लॉगिंग

कार्य

मान लें कि हम एक निश्चित जावा वर्ग की प्रत्येक विधि को अलग तरीके से लॉग इन करना चाहते हैं:

• प्रत्येक विधि की अपनी लॉग फ़ाइल होती है,
• ... आपका लॉग प्रारूप,
• ... लॉगिंग का इसका न्यूनतम स्तर,
• हम अपने स्वयं के % साथ लॉग प्रारूप का विस्तार करते हैं,
• मक्खी पर इस विन्यास को अद्यतन करने की क्षमता।

यह आलेख बताता है कि इन आवश्यकताओं को कैसे पूरा किया जाए। सादगी बनाए रखने के लिए, लॉगिंग का पृथक्करण केवल विधियों द्वारा किया जाता है; वास्तव में, आप एक पदानुक्रमित योग्यता प्राप्त करना चाहते हैं, जैसे → → → ... पूर्ण स्रोत कोड का लिंक नीचे होगा।

ग्राहक कोड

  class ThingService { log = LoggerFactory.getLogger(); getThing() { log.debug("getThing..."); // => one.log } listThings() { log.debug("listThings..."); // => another.log } } 

Logback

कार्यान्वयन के लिए, एक ठोस "लॉगबैक" लॉगिंग लाइब्रेरी का चयन किया गया था, जो अनुकूलन के लिए दिलचस्प संभावनाएं प्रदान करता है:

 ch.qos.logback:logback-classic:1.2.3 

इसे XML कॉन्फिगर और जावा से सीधे दोनों से कॉन्फ़िगर किया गया है, एप्रोच को संयोजित किया जा सकता है:

  public void configureLogback() throws JoranException { LoggerContext lc = LoggerFactory.getILoggerFactory(); lc.reset(); // reset prev config JoranConfigurator configurator = new JoranConfigurator(); configurator.setContext(lc); configurator.doConfigure("config.xml"); // any data source StatusPrinter.printInCaseOfErrorsOrWarnings(lc); //   : Logger root = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); root.setLevel(Level.INFO); //  } 

लॉगिंग के बारे में संक्षेप में:

1. प्रोग्रामर लकड़हारा खींचता है,
2. लकड़हारा उसे सौंपे गए परिशिष्टों को खींचता है,
3. परिशिष्ट सोचता है और एनकोडर को बुलाता है,
4. एनकोडर प्रारूप में लॉग की एक पंक्ति है,
5. ऐसा करने के लिए, वह कन्वर्टर्स की एक श्रृंखला खींचता है, जिनमें से प्रत्येक अपने % खुलासा करता % ,
6. सफलता।

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

  Logger rootLogger = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); LoggerContext lc = rootLogger.getLoggerContext(); lc.reset(); // reset prev config var encoder = new PatternLayoutEncoder(); encoder.setContext(lc); encoder.setPattern("%-5level %message%n"); encoder.start(); var appender = new ConsoleAppender<ILoggingEvent>(); appender.setContext(lc); appender.setEncoder(encoder); appender.start(); rootLogger.setLevel(Level.DEBUG); rootLogger.addAppender(appender); 

एक दूसरे से लॉग इन विधियों को अलग करें

ताकि लॉगबैक विधि को कॉल करने से पहले एक विधि को दूसरे से अलग कर सके, उसका नाम ThreadLocal मैप्ड डायग्नोस्टिक संदर्भ में सहेजें। इसके अलावा, विश्लेषण के दौरान, हम इन मूल्यों को सीधे MDC वर्ग से प्राप्त नहीं करते हैं, क्योंकि लॉगिंग कोड को किसी अन्य थ्रेड में निष्पादित किया जाएगा और यह डेटा नहीं होगा - हम उन्हें ILoggingEvent.getMDCPropertyMap() माध्यम से प्राप्त करते हैं।

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

  try { MDC.put(MDC_KEY_METHOD, currentMethod); // 1.  currentMethod    // 2.    // 3.       AOP, . } finally { String previousMethod = //     MDC.put(previousMethod); } 

प्रत्येक विधि के लिए स्वयं की लॉग फ़ाइल

आइए बनाते हैं और अपने स्वयं के परिशिष्ट को पंजीकृत करना न भूलें:

  class MultiAppender extends AppenderBase<ILoggingEvent> { @Override protected void append(ILoggingEvent event) { method = event.getMDCPropertyMap().get(MDC_KEY_METHOD); Appender appender = getOrCreateAppender(method); appender.doAppend(event); } 

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

  fileAppender = new FileAppender<ILoggingEvent>(); fileAppender.setContext(lc); fileAppender.setAppend(false); fileAppender.setEncoder(getOrCreateEncoderByMethod(lc, method)); fileAppender.setFile(logFileByMethod.get(method)); fileAppender.start(); 

प्रत्येक विधि के लिए स्वयं का प्रारूप

ऐसा करने के लिए, Encoder प्रकार की ऑटो-निर्मित वस्तुओं का कैश रखें:

  Map<String, String> patternByMethod = new HashMap<>(); //  ;  Encoder getOrCreateEncoderByMethod(LoggerContext lc, String method) { String pattern = patternByMethod.get(method); encoder = new PatternLayoutEncoder(); encoder.setContext(lc); encoder.setPattern(pattern); encoder.start(); return encoder; } 

प्रत्येक विधि का लॉगिंग का अपना स्तर होता है

MultiAppender वर्ग में एक चेक जोड़ते हैं: यदि इवेंट स्तर विधि के लिए निर्दिष्ट सीमा MultiAppender , तभी हम इसे लॉग करते हैं:

  Map<String, Level> levelByMethod = new HashMap<>(); protected void append(ILoggingEvent event) { Level minLevel = levelByMethod.get(methodName); if (event.getLevel().levelInt >= minLevel.levelInt) { appender.doAppend(event); } 

सिद्धांत रूप में, इस तर्क को फ़िल्टर में रखा जा सकता है।

अपने चर के साथ प्रारूप का विस्तार

अपने बगीचे को बाड़ न करने के लिए, लेकिन लॉग-बैक के सिद्ध बुनियादी ढांचे का लाभ उठाने के लिए, आपको अपने स्वयं के कनवर्टर वर्ग को परिभाषित करने की आवश्यकता है, पूरी तरह से सार्वजनिक होना सुनिश्चित करें ताकि इसे बाहर से तुरंत लगाया जा सके। यदि आपको MDC आवश्यकता है, तो इसे घटना से लें। %custom चर हैंडलर यहाँ शुरू होता है:

  public class CustomConverter extends ClassicConverter { public String convert(ILoggingEvent event) { // mdc = event.getMDCPropertyMap(); return "variable-expanded"; } } 

सामान्य कॉन्फ़िगरेशन प्रक्रिया के दौरान, हैंडलर को पंजीकृत करें:

  void configurePatterns(LoggerContext lc) { Map<String, String> rules = lc.getObject(CoreConstants.PATTERN_RULE_REGISTRY); if (rules == null) { rules = new HashMap<String, String>(); lc.putObject(CoreConstants.PATTERN_RULE_REGISTRY, rules); } rules.put("custom", CustomConverter.class.getName()); } 

और हम एक एनकोडर के रूप में उपयोग करेंगे, उदाहरण के लिए, PatternLayoutEncoder , जो सब कुछ PatternLayoutEncoder । इस स्थिति में, %custom चर स्ट्रिंग "variable-expanded" ।

मक्खी पर विन्यास अद्यतन

बॉक्स से बाहर एक ऐसा अवसर है: यह विन्यासकर्ता फ़ंक्शन को फिर से कॉल करने के लिए पर्याप्त है, LoggerContext::reset() करना न LoggerContext::reset() और संचित कैश को साफ़ करें।

बहु सूत्रण

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

  Map<String, String> mdcOrig = MDC.getCopyOfContextMap(); ExecutorService es = Executors.newFixedThreadPool(1); es.submit(() -> threadWorker(mdcOrig)); void threadWorker(Map<String, String> parentMdc) { MDC.setContextMap(parentMdc); log.error("expected to appear in method2*.log"); } 

पूरा उदाहरण

https://github.com/zencd/logback-setup

साहित्य

आधिकारिक लॉगबैक मैनुअल