एक्लेयर - जावा स्प्रिंग डिक्लेरेशन लॉगिंग लाइब्रेरी

विकास, परीक्षण और समर्थन के चरणों में सेवाओं के काम के बारे में बहुत सारे प्रश्न हैं, और उनमें से सभी पहली नज़र में हैं: "क्या हुआ?" , "क्या कोई अनुरोध था?" , "दिनांक प्रारूप क्या है?" , "सेवा जवाब क्यों नहीं दे रही है?" आदि

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

कंबल और समाधान की सुविधाओं के बारे में - नीचे।

लॉगिंग की समस्या क्या है

यदि आप परिसर को समझने में बहुत रुचि नहीं रखते हैं, तो आप तुरंत हमारे समाधान के विवरण के लिए आगे बढ़ सकते हैं ।

• एप्लिकेशन लॉग इसकी एल्बी है।
  सबसे अधिक बार, केवल वह आवेदन की सफलता साबित कर सकता है। एक microservice में कोई राज्य नहीं है, आसन्न सिस्टम मोबाइल और नकचढ़ा हैं। "दोहराएं", "फिर से बनाना", "डबल-चेक" - यह सब मुश्किल और / या असंभव है। प्रश्न का उत्तर देने के लिए लॉग पर्याप्त रूप से जानकारीपूर्ण होना चाहिए: "क्या हुआ?" किसी भी समय । । लॉग सभी के लिए स्पष्ट होना चाहिए: डेवलपर, परीक्षक, कभी-कभी विश्लेषक, कभी-कभी व्यवस्थापक, कभी-कभी समर्थन की पहली पंक्ति - कुछ भी होता है।
• माइक्रोसिस्टम्स मल्टीथ्रेडिंग के बारे में हैं।
  सेवा में आने वाले अनुरोध (या सेवा द्वारा अनुरोधित डेटा) सबसे अक्सर कई थ्रेड द्वारा संसाधित किए जाते हैं। सभी थ्रेड्स का लॉग आमतौर पर मिश्रित होता है। क्या आप समानांतर धागे के बीच अंतर करना चाहते हैं और "अनुक्रमिक" धागे के बीच अंतर करना चाहते हैं? अलग-अलग डेटा सेट के लिए अपने स्वयं के तर्क को निष्पादित करने के लिए अनुरोधों के अनुक्रमिक प्रसंस्करण के लिए एक ही धारा का पुन: उपयोग किया जाता है। ये "अनुक्रमिक" दूसरे विमान से बहते हैं, लेकिन उनकी सीमाएं पाठक को स्पष्ट होनी चाहिए।
• लॉग को मूल डेटा प्रारूप को सहेजना चाहिए।
  यदि वास्तविकता सेवाओं में एक्सएमएल द्वारा एक्सचेंज किया जाता है, तो संबंधित लॉग को एक्सएमएल स्टोर करना चाहिए। यह हमेशा कॉम्पैक्ट नहीं होता है और हमेशा सुंदर (लेकिन सुविधाजनक) नहीं होता है। असफलता का विश्लेषण करना आसान है, सफलता देखना आसान है। कुछ मामलों में, लॉग का उपयोग मैन्युअल रूप से खेलने या अनुरोध को पुन: संसाधित करने के लिए किया जा सकता है।
• लॉग में डेटा का हिस्सा एक विशेष संबंध की आवश्यकता है।
  आने वाले डेटा (अनुरोध), आउटगोइंग डेटा (उत्तर), तीसरे पक्ष के सिस्टम के अनुरोध और उनसे प्रतिक्रियाएं अक्सर अलग-अलग संग्रहीत करने की आवश्यकता होती है। वे विशेष आवश्यकताओं के अधीन हैं: शेल्फ जीवन या विश्वसनीयता द्वारा। इसके अलावा, इस डेटा में एक सामान्य लॉग लाइन की तुलना में प्रभावशाली राशि हो सकती है।
• डेटा का हिस्सा लॉग के लिए नहीं है।
  निम्नलिखित को आमतौर पर नियमित लॉग से बाहर रखा जाना चाहिए: बाइनरी डेटा (बाइट एरे, बेस 64, ..), ग्राहकों / भागीदारों / अन्य व्यक्तियों और कानूनी संस्थाओं के व्यक्तिगत डेटा। यह हमेशा एक व्यक्तिगत कहानी है, लेकिन व्यवस्थित है और मैनुअल नियंत्रण के लिए खुद को उधार नहीं देता है।

हाथ क्यों नहीं?

org.slf4j.Logger लें (किसी भी सूट के org.slf4j.Logger के साथ इसे org.slf4j.Logger करें) और लॉग के लिए आवश्यक सब कुछ लिखें। मुख्य तरीकों के लिए प्रवेश, बाहर निकलता है, यदि आवश्यक हो, तो पकड़ा त्रुटियों को प्रतिबिंबित करता है, कुछ डेटा। क्या यह आवश्यक है? हाँ, लेकिन:

• कोड की मात्रा अनुचित रूप से (असामान्य रूप से) बढ़ रही है। सबसे पहले, यह बहुत हड़ताली नहीं है, अगर आप केवल सबसे बुनियादी (सफल समर्थन, इस दृष्टिकोण के साथ) लॉग करते हैं।
• अपने हाथों से लकड़हारा को कॉल करना जल्दी से आलस्य बन जाता है। एक लकड़हारे के साथ एक static क्षेत्र घोषित करना बहुत आलसी है (ठीक है, लोम्बोक हमारे लिए ऐसा कर सकता है)। हम डेवलपर्स आलसी हैं। और हम अपने आलस्य को सुनते हैं, यह महान आलस्य है: यह लगातार दुनिया को बेहतर के लिए बदल रहा है।
• सभी पक्षों पर माइक्रोसॉर्क्स अच्छे नहीं हैं। हां, वे छोटे और सुंदर हैं, लेकिन एक फ्लिप पक्ष है: कई हैं! शुरुआत से अंत तक एक एकल अनुप्रयोग अक्सर एक डेवलपर द्वारा लिखा जाता है। विरासत उसकी आंखों के सामने नहीं फूटती। खुश, लगाए गए नियमों के बोझ से दबे नहीं, डेवलपर अपने स्वयं के लॉग प्रारूप, अपने सिद्धांत और अपने नियमों का आविष्कार करना एक कर्तव्य मानता है। फिर, शानदार ढंग से आविष्कार को लागू करता है। हर वर्ग अलग है। क्या यह एक समस्या है? भारी।
• रिफैक्टरिंग आपके लॉग को तोड़ देगा। यहां तक ​​कि सर्वशक्तिमान आइडिया भी उसे नहीं बचाएगा। लॉग को अपडेट करना उतना ही असंभव है जितना कि Javadoc को अपडेट करना। उसी समय, कम से कम Javadoc केवल डेवलपर्स (नहीं, कोई भी नहीं पढ़ता है) द्वारा पढ़ा जाता है, लेकिन लॉग के दर्शक बहुत व्यापक हैं और विकास टीम सीमित नहीं है।
• MDC (मैप्ड डायग्नोस्टिक कॉन्सेप्ट) एक बहु-थ्रेडेड एप्लिकेशन का एक अभिन्न अंग है। एमडीसी के मैनुअल भरने के लिए धारा में काम के अंत में समय पर सफाई की आवश्यकता होती है। अन्यथा, आप एक ThreadLocal को गैर-संबंधित डेटा से बांधने का जोखिम चलाते हैं। इसे नियंत्रित करने के लिए हाथ और आंखें, मैं कहने की हिम्मत करता हूं, असंभव है।

और हम अपने अनुप्रयोगों में इन समस्याओं को हल करते हैं।

एक्लेयर क्या है और यह क्या कर सकता है

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

मुख्य लक्ष्य विकास प्रक्रिया में सभी प्रतिभागियों को लॉग स्पष्ट करना है। इसलिए, कोड लिखने की सुविधा, एक्लेयर के लाभ समाप्त नहीं होते हैं, लेकिन केवल शुरू होते हैं।

Eclair लॉग एनोटेट विधियों और मापदंडों:

• विधि से प्रवेश / निकास विधि / अपवाद / तर्क / तर्क / मान विधि से लौटा
• विशेष रूप से टाइप करने के लिए उन्हें लॉग इन करने के लिए अपवाद: केवल जहाँ आवश्यक हो
• वर्तमान स्थान के लिए एप्लिकेशन सेटिंग्स के आधार पर लॉग का "विवरण" बदलता है: उदाहरण के लिए, सबसे विस्तृत मामले में यह सबसे कम संस्करण में तर्कों (सभी या कुछ) के मूल्यों को प्रिंट करता है - केवल विधि में प्रवेश करने का तथ्य
• JSON / XML / किसी अन्य प्रारूप में डेटा प्रिंट करता है (जैक्सन के साथ काम करने के लिए तैयार, JAXB बॉक्स से बाहर): यह समझता है कि किसी विशेष पैरामीटर के लिए कौन सा प्रारूप सबसे बेहतर है
• घोषणात्मक स्थापना और एमडीसी ऑटो-सफाई के लिए स्पेल (स्प्रिंग एक्सप्रेशन लैंग्वेज) को समझता है
• एन लॉगर्स को लिखते हैं, एक्लेयर की समझ में "लकड़हारा" इस संदर्भ में एक बीन है जो EclairLogger इंटरफ़ेस को लागू करता है: आप उस EclairLogger को निर्दिष्ट कर सकते हैं जिसे नाम से, उपनाम से या डिफ़ॉल्ट रूप से एनोटेशन को संसाधित करना चाहिए।
• प्रोग्रामर को एनोटेशन का उपयोग करने में कुछ त्रुटियों के बारे में बताता है: उदाहरण के लिए, एक्लेयर जानता है कि यह डायनेमिक प्रॉक्सी पर काम करता है (सभी आगामी सुविधाओं के साथ), इसलिए, यह सुझाव दे सकता है कि private पद्धति पर एनोटेशन कभी काम नहीं करेगा।
• मेटा एनोटेशन स्वीकार करता है (जैसा कि स्प्रिंग उन्हें कहता है): आप कुछ मूल एनोटेशन का उपयोग करके लॉगिंग के लिए अपने एनोटेशन को परिभाषित कर सकते हैं - कोड को कम करने के लिए
• प्रिंट करते समय "संवेदनशील" डेटा को मुखौटा करने में सक्षम: एक्सपीथ-शील्डिंग एक्सएमएल से बाहर
• "मैनुअल" मोड में एक लॉग लिखता है, इनवोक को परिभाषित करता है और Supplier लागू करने वाले तर्कों को "विस्तारित" करता है: तर्कों को शुरू करने का अवसर देते हुए "आलसी"

एक्लेयर को कैसे कनेक्ट करें

स्रोत कोड अपाचे 2.0 लाइसेंस के तहत गिटहब पर प्रकाशित हुआ है ।

कनेक्ट करने के लिए, आपको जावा 8, मावेन और स्प्रिंग बूट 1.5+ की आवश्यकता है। मावेन सेंट्रल रिपोजिटरी द्वारा आयोजित कलाकृतियों:

 <dependency> <groupId>ru.tinkoff</groupId> <artifactId>eclair-spring-boot-starter</artifactId> <version>0.8.3</version> </dependency> 

स्टार्टर में EclairLogger का एक मानक कार्यान्वयन होता है, जो कुछ सत्यापित सेटिंग के साथ स्प्रिंग बूट द्वारा आरंभ किए गए लॉगिंग सिस्टम का उपयोग करता है।

उदाहरण

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

सरलतम उदाहरण

डिफ़ॉल्ट स्तर DEBUG है।

 @Log void simple() { } 

अगर स्तर उपलब्ध है	... फिर लॉग इस तरह होगा
TRACE DEBUG	DEBUG [] rteeExample.simple > DEBUG [] rteeExample.simple <
INFO WARN ERROR	-

लॉग विवरण उपलब्ध लॉगिंग स्तर पर निर्भर करता है।

वर्तमान स्थान में उपलब्ध लॉगिंग स्तर लॉग विवरण को प्रभावित करता है। कम उपलब्ध स्तर (यानी, TRACE के करीब), और अधिक विस्तृत लॉग।

 @Log(INFO) boolean verbose(String s, Integer i, Double d) { return false; } 

स्तर	लॉग फ़ाइल
TRACE DEBUG	INFO [] rteeExample.verbose > s="s", i=4, d=5.6 INFO [] rteeExample.verbose < false
INFO	INFO [] rteeExample.verbose > INFO [] rteeExample.verbose <
WARN ERROR	-

फ़ाइन-ट्यूनिंग अपवाद लॉगिंग

लॉग किए गए अपवादों के प्रकार फ़िल्टर किए जा सकते हैं। चयनित अपवादों और उनके वंशजों को गिरवी रखा जाएगा। इस उदाहरण में, NullPointerException को WARN स्तर पर लॉग किया जाएगा, ERROR स्तर पर Exception (डिफ़ॉल्ट रूप से), और Error बिल्कुल भी लॉग इन नहीं होगी (क्योंकि Error पहले एनोटेशन @Log.error के फिल्टर में शामिल नहीं है और स्पष्ट रूप से दूसरी एनोटेशन के फ़िल्टर से बाहर रखा गया है)।

 @Log.error(level = WARN, ofType = {NullPointerException.class, IndexOutOfBoundsException.class}) @Log.error(exclude = Error.class) void filterErrors(Throwable throwable) throws Throwable { throw throwable; } //       filterErrors(new NullPointerException()); filterErrors(new Exception()); filterErrors(new Error()); 

स्तर	लॉग फ़ाइल
TRACE DEBUG INFO WARN	WARN [] rteeExample.filterErrors ! java.lang.NullPointerException java.lang.NullPointerException: null at rteeExampleTest.filterErrors(ExampleTest.java:0) .. ERROR [] rteeExample.filterErrors ! java.lang.Exception java.lang.Exception: null at rteeExampleTest.filterErrors(ExampleTest.java:0) ..
ERROR	ERROR [] rteeExample.filterErrors ! java.lang.Exception java.lang.Exception: null at rteeExampleTest.filterErrors(ExampleTest.java:0) ..

प्रत्येक पैरामीटर को अलग से सेट करें

 @Log.in(INFO) void parameterLevels(@Log(INFO) Double d, @Log(DEBUG) String s, @Log(TRACE) Integer i) { } 

स्तर	लॉग फ़ाइल
TRACE	INFO [] rteeExample.parameterLevels > d=9.4, s="v", i=7
DEBUG	INFO [] rteeExample.parameterLevels > d=9.4, s="v"
INFO	INFO [] rteeExample.parameterLevels > 9.4
WARN ERROR	-

प्रिंटआउट प्रारूप का चयन करें और अनुकूलित करें

प्रिंट प्रारूप के लिए जिम्मेदार "प्रिंटर" को प्री- और पोस्ट-प्रोसेसर द्वारा कॉन्फ़िगर किया जा सकता है। उपरोक्त उदाहरण में, maskJaxb2Printer कॉन्फ़िगर किया गया है ताकि XPath अभिव्यक्ति "//s" मेल खाने वाले तत्वों को "********" का उपयोग करके मास्क किया जाए। उसी समय, jacksonPrinter Dto "जैसा है" प्रिंट किया।

 @Log.out(printer = "maskJaxb2Printer") Dto printers(@Log(printer = "maskJaxb2Printer") Dto xml, @Log(printer = "jacksonPrinter") Dto json, Integer i) { return xml; } 

स्तर	लॉग फ़ाइल
TRACE DEBUG	DEBUG [] rteeExample.printers > xml=<dto><i>5</i><s>********</s></dto>, json={"i":5,"s":"password"} DEBUG [] rteeExample.printers < <dto><i>5</i><s>********</s></dto>
INFO WARN ERROR	-

संदर्भ में कई लोग

एक ही समय में कई लॉगर का उपयोग करके विधि को लॉग किया जाता है: डिफ़ॉल्ट लकड़हारा ( @Primary का उपयोग करके एनोटेट) और ऑडलॉगगर auditLogger । आप कई लॉगर्स को परिभाषित कर सकते हैं यदि आप लॉग इवेंट को न केवल स्तर (TRACE - ERROR) से अलग करना चाहते हैं, बल्कि उन्हें अलग-अलग स्टोरेज में भी भेज सकते हैं। उदाहरण के लिए, मुख्य लकड़हारा slf4j का उपयोग करके डिस्क पर एक फ़ाइल के लिए एक लॉग लिख सकता है, और auditLogger अपने स्वयं के विशिष्ट प्रारूप में एक विशेष डेटा स्लाइस को एक उत्कृष्ट भंडारण (उदाहरण के लिए, काफ्का में) में लिख सकता है।

 @Log @Log(logger = "auditLogger") void twoLoggers() { } 

एमडीसी प्रबंधन

एनोटेशन का उपयोग करके सेट किए गए MDCs, एनोटेट विधि से बाहर निकलने के बाद स्वचालित रूप से हटा दिए जाते हैं। एक एमडीसी रिकॉर्ड मूल्य की गणना गतिशील रूप से स्पेल का उपयोग करके की जा सकती है। निम्नलिखित उदाहरण हैं: स्थिर स्थिरांक द्वारा स्थिर स्थैतिक स्ट्रिंग, अभिव्यक्ति 1 + 1 मूल्यांकन करते हुए, jacksonPrinter को कॉल करके, static विधि को randomUUID ।
global = true साथ MDCs global = true विशेषता विधि से बाहर निकलने के बाद नहीं हटाई जाती है: जैसा कि आप देख सकते हैं, लॉग के अंत तक MDC में एकमात्र रिकॉर्ड शेष है।

 @Log void outer() { self.mdc(); } @Mdc(key = "static", value = "string") @Mdc(key = "sum", value = "1 + 1", global = true) @Mdc(key = "beanReference", value = "@jacksonPrinter.print(new ru.tinkoff.eclair.example.Dto())") @Mdc(key = "staticMethod", value = "T(java.util.UUID).randomUUID()") @Log void mdc() { self.inner(); } @Log.in void inner() { } 

उपरोक्त कोड निष्पादित करते समय लॉग इन करें:
DEBUG [] rteeExample.outer >
DEBUG [beanReference={"i":0,"s":null}, sum=2, static=string, staticMethod=01234567-89ab-cdef-ghij-klmnopqrstuv] rteeExample.mdc >
DEBUG [beanReference={"i":0,"s":null}, sum=2, static=string, staticMethod=01234567-89ab-cdef-ghij-klmnopqrstuv] rteeExample.inner >
DEBUG [beanReference={"i":0,"s":null}, sum=2, static=string, staticMethod=01234567-89ab-cdef-ghij-klmnopqrstuv] rteeExample.mdc <
DEBUG [sum=2] rteeExample.outer <

पैरामीटर MDC स्थापना के आधार पर

यदि आप पैरामीटर पर एनोटेशन का उपयोग करके एमडीसी निर्दिष्ट करते हैं, तो एनोटेट पैरामीटर मूल्यांकन संदर्भ के मूल ऑब्जेक्ट के रूप में उपलब्ध है। यहां "s" टाइप String साथ वर्ग Dto का एक क्षेत्र है।

 @Log.in void mdcByArgument(@Mdc(key = "dto", value = "#this") @Mdc(key = "length", value = "s.length()") Dto dto) { } 

उपरोक्त कोड निष्पादित करते समय लॉग इन करें:
DEBUG [length=8, dto=Dto{i=12, s='password'}] rteeExample.mdcByArgument > dto=Dto{i=12, s='password'}

मैनुअल लॉगिंग

"मैनुअल" लॉगिंग के लिए, यह ManualLogger के कार्यान्वयन को लागू करने के लिए पर्याप्त है। पास किए गए तर्क जो इंटरफ़ेस Supplier को लागू करते हैं, केवल यदि आवश्यक हो तो "विस्तारित" होगा।

 @Autowired private ManualLogger logger; @Log void manual() { logger.info("Eager logging: {}", Math.PI); logger.debug("Lazy logging: {}", (Supplier) () -> Math.PI); } 

स्तर	लॉग फ़ाइल
TRACE DEBUG	DEBUG [] rteeExample.manual > INFO [] rteeExample.manual - Eager logging: 3.141592653589793 DEBUG [] rteeExample.manual - Lazy logging: 3.141592653589793 DEBUG [] rteeExample.manual <
INFO	INFO [] rteeExample.manual - Eager logging: 3.141592653589793
WARN ERROR	-

एक्लेयर क्या नहीं करता है

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

EclairLogger का एक उदाहरण विन्यास एक लॉग को लॉगबैक लकड़हारे को एक विशिष्ट परिशिष्ट के साथ निर्देशित करता है:

 @Bean public EclairLogger eclairLogger() { LoggerFacadeFactory factory = loggerName -> { ch.qos.logback.classic.LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); ch.qos.logback.classic.Logger logger = context.getLogger(loggerName); // Appender<ILoggingEvent> appender = ? // logger.addAppender(appender); return new Slf4JLoggerFacade(logger); }; return new SimpleLogger(factory, LoggingSystem.get(SimpleLogger.class.getClassLoader())); } 

यह समाधान सभी के लिए नहीं है।

इससे पहले कि आप लॉगिंग के मुख्य उपकरण के रूप में एक्लेयर का उपयोग शुरू करें, आपको इस समाधान की कई विशेषताओं के साथ खुद को परिचित करना चाहिए। ये "विशेषताएं" इस तथ्य के कारण हैं कि एक्लेयर वसंत के लिए मानक प्रॉक्सी तंत्र पर आधारित है।

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

- स्टैकट्रेस "ब्लोट" थोड़ा और अधिक। यदि आप स्प्रिंग प्रॉक्सिस के लंबे स्टैकट्रेस के लिए उपयोग नहीं किए जाते हैं, तो यह आपके लिए एक उपद्रव हो सकता है। समान रूप से स्पष्ट कारण के लिए, समीपवर्ती वर्गों को डिबग करना कठिन होगा।

- हर वर्ग और हर विधि को सम्‍मिलित नहीं किया जा सकता है : private विधियों को सम्‍मिलित नहीं किया जा सकता है, आपको एक बीन में विधियों की श्रृंखला को लॉग करने के लिए स्‍वयं की आवश्‍यकता होगी, आप ऐसी किसी भी चीज का छद्म नहीं कर सकते जो सेम नहीं है, आदि।

अंत में

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

आलोचना, विचार, संकेत, लिंक - मैं परियोजना के जीवन में आपकी किसी भी भागीदारी का गर्मजोशी से स्वागत करता हूं! मुझे खुशी होगी कि यदि आप अपनी परियोजनाओं के लिए एक्लेयर को उपयोगी पाते हैं।