नेस्टेड डायग्नोस्टिक कॉन्सेप्ट, log4cpp और Boost asio

इस लेख में मैं यह दिखाना चाहता हूं कि आप log4cpp और boost.tio के उदाहरण का उपयोग करके अतुल्यकालिक संचालन में NDC का उपयोग कैसे कर सकते हैं।

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

सिद्धांत रूप में, सब कुछ ठीक है: हम एक विशिष्ट आईडी बनाते हैं और इसे लकड़हारे को सौंप देते हैं, हालांकि, व्यवहार में, कई समस्याएं उत्पन्न होती हैं:

• Log4cpp लाइब्रेरी में NDC कार्यान्वयन थ्रेड लोकल स्टोरेज (थ्रेड स्पेसिफिक Ptr) तंत्र पर आधारित है, इसलिए NDC केवल एक थ्रेड के लिए संग्रहीत है। तदनुसार, प्रश्न थ्रेड्स के बीच एनडीसी को प्रसारित करने पर उठता है
• निम्न समस्या पहले पैराग्राफ से भी उत्पन्न होती है: अतुल्यकालिक संचालन, उदाहरण के लिए बढ़ावा देने में :: asio :: io_service। चूंकि asio आपको एक (या कई) थ्रेड्स में कई अतुल्यकालिक ऑपरेशन करने की अनुमति देता है, log4cpp की प्रकृति के कारण, हम लॉग में सही NDC नहीं देख पाएंगे। हमें एक विशेष तंत्र की आवश्यकता है जो कि एसियो तुल्यकालिक संचालन में सही एनडीसी सुनिश्चित करेगा

तैयारी शुरू करें

• CMake-2.8 एक निर्माण प्रणाली के रूप में
• बूस्ट मट्ठा रिपोजिटरी से बूस्ट -१.४ ९
• log4cpp - लॉगिंग लाइब्रेरी
• C ++ 11 सक्षम के साथ gcc-4.7.1 (वैरेडिक टेम्प्लेट का उपयोग करके)
• स्रोत कोड asio_log4cpp उपनिर्देशिका में GitHub पर है

उदाहरण का संक्षिप्त विवरण

उदाहरण एक ग्राहक और सर्वर को लागू करता है जो संदेशों का आदान-प्रदान करता है

सर्वर ऑपरेशन सिद्धांत:

• सर्वर 12345 पोर्ट पर किसी भी पते से कनेक्शन की प्रतीक्षा कर रहा है
• कनेक्ट करने के बाद, यह 0 से 1000 तक की सीमा में एक मनमाना संख्या उत्पन्न करता है (बूस्ट.ब्रांड लाइब्रेरी का उपयोग पीढ़ी के लिए किया जाता है, मेर्सन व्हर्लविंड जनरेटर के रूप में उपयोग किया जाता है)
• क्लाइंट को उत्पन्न संख्या भेजता है
• मिलीसेकंड की निर्दिष्ट संख्या के लिए एक अतुल्यकालिक टाइमर शुरू करता है
• टाइमर के काम करने के बाद, यह एसिंक्रोनस रीडिंग शुरू करता है, क्लाइंट से एक संदेश प्राप्त करता है और सत्र समाप्त करता है

क्लाइंट उसी तरह काम करता है:

• पता करने के लिए 100 अतुल्यकालिक कनेक्शन शुरू होता है 127.0.0.1:12345
• कनेक्ट करने के बाद, यह सर्वर से एक संदेश पढ़ता है जिसमें टाइमआउट होता है
• मिलीसेकंड की निर्दिष्ट संख्या के लिए एक अतुल्यकालिक टाइमर शुरू करता है
• टाइमर के काम करने के बाद, यह एसिंक्रोनस रिकॉर्डिंग शुरू करता है, सर्वर को एक विदाई संदेश भेजता है।

इस उदाहरण में, मैंने विशेष रूप से यह दिखाने के लिए एक मनमाना समय बनाया कि एनडीसी को अतुल्यकालिक संचालन में कैसे संसाधित किया जाता है।

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

हम एनडीसी के बिना क्लाइंट और सर्वर शुरू करते हैं

यदि हम उदाहरणों को सरल पैरामीटर के साथ चलाते हैं, तो हम लगभग निम्नलिखित सामग्रियों (क्लाइंट के लिए) की स्क्रीन लाइनों पर देखेंगे:

17 INFO connection status: system:0, message: Success 17 INFO starting asynchronous reading... ... 33 INFO answer from server readed: [552] 33 INFO starting asynchronous timeout 00:00:00.552000 ... ... 141 INFO timer status: system:0, message: Success 141 INFO starting asynchronous write... 141 INFO write status: system:0, message: Success, bytes written: 8 

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

कार्यान्वयन का विवरण

पहले, log4cpp में NDC समर्थन सक्षम करें। ऐसा करने के लिए, हम पैटर्नकॉलआउट क्लास का उपयोग करते हैं, सेटकोवर्सनपैटर्न विधि का उपयोग करते हुए, हम हमें दिखाई देने वाली जानकारी उत्पन्न करते हैं। % X पैरामीटर NDC के आउटपुट के लिए ज़िम्मेदार है (देखें consts :: ndcLayoutPattern आम फ़ाइल में)

विकल्प # 1

निम्नलिखित विचार मन में आता है: चूंकि asio किसी भी कंप्लीशनहैंडलर (जो कि हस्ताक्षर को संतुष्ट करता है ) को स्वीकार करता है, हम निम्नलिखित तरीके से अपने कम्प्लीशनहैंडलर को लपेट सकते हैं:

 struct NdcHolder : private boost::noncopyable { NdcHolder(const std::string & ndc) { log4cpp::NDC::push(ndc); } ~NdcHolder() { log4cpp::NDC::pop(); } }; //... template <typename Oldhandler> void newHandler(OldHandler func, const std::string & ndc) { NdcHolder ndcHolder(ndc); func(); } 

स्वाभाविक रूप से, हमें एक और हैंडलर में फंक और ndc लपेटना होगा, उदाहरण के लिए, बढ़ावा :: बाइंड, या हमारे फ़ंक्शन का उपयोग करना

इस कोड के साथ, हम अपने हैंडलर को निष्पादित करने से पहले एनडीसी स्थापित करते हैं और निष्पादन के बाद इसे हटा देते हैं।

हमें अपने हैंडलर के पूरा होने के बाद NDC को रीसेट करना चाहिए, अन्यथा हम लॉग में अमान्य NDC के साथ संदेश देख सकते हैं

विकल्प # 2

एसियो लाइब्रेरी द्वारा पेश किया गया एक अधिक विहित संस्करण हैंडलर इनवोकेशन तंत्र का उपयोग है।
यह तंत्र आपको हैंडलर को निष्पादित करने के लिए अपने स्वयं के फ़ंक्शन को लिखने की अनुमति देता है।

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

डिफ़ॉल्ट रूप से, यह फ़ंक्शन बूस्ट / asio / handler_invoke_hook.hpp में निम्नानुसार परिभाषित किया गया है:

 template <typename Function> inline void asio_handler_invoke(Function function, ...) { function(); } 

यह एक फ़ंक्शन है जो एक चर संख्या में तर्क लेता है (लेकिन केवल पहले तर्क का उपयोग करता है)। यह ज्ञात है कि कॉल करने के लिए फ़ंक्शन की खोज करते समय, चर संख्या के साथ एक फ़ंक्शन में सबसे कम प्राथमिकता होती है, इसलिए इस तरह के कार्यान्वयन को प्रतिस्थापित किया जाएगा यदि कोई अन्य कार्यान्वयन निर्दिष्ट नहीं किया जाता है।

इसे बूस्ट / asio / डिटेल / हैंडलर_invoke_helpers.hpp में इस तरह से उपयोग किया जाता है ( थ्रो ड्रोसोफर्स :

 template <typename Function, typename Context> inline void invoke(Function& function, Context& context) { using boost::asio::asio_handler_invoke; asio_handler_invoke(function, boost::addressof(context)); } 

जिस फ़ंक्शन के लिए हमें बुलाया जाना चाहिए, उसके लिए यह आवश्यक है कि चुनते समय यह एक उच्च प्राथमिकता हो, और दो मापदंडों को स्वीकार कर सकता है, पहला पैरामीटर स्वयं हैंडलर है, और दूसरा पैरामीटर एक निश्चित संदर्भ है जिसमें हमारे हैंडलर को निष्पादित किया जाएगा। हमारे मामले में, फ़ंक्शन और संदर्भ समान हैं (मोटे तौर पर बोलते हुए, एसियो एक हैंडलर लेता है और इसे फ़ंक्शन और संदर्भ के रूप में दोनों का उपयोग करता है)। इस प्रकार, हमारा कार्य एक विशेष प्रकार का कंप्लीशनहैंडलर और फ़ंक्शन asio_handler_invoke लिखना है

आइए हैंडलर के कार्यान्वयन से शुरू करें:

 template <typename HandlerT> class NdcDecorator { public: explicit NdcDecorator(HandlerT handler, const std::string & ndc) : mHandler(handler), mNdc(ndc) {} void operator()() { mHandler(); } template <typename Arg1> void operator() (Arg1 arg1) { mHandler(arg1); } template <typename Arg1, typename Arg2> void operator() (Arg1 arg1, Arg2 arg2) { mHandler(arg1, arg2); } const std::string & ndc() const { return mNdc; } private: HandlerT mHandler; std::string mNdc; }; 

आसियो को हमारे हैंडलर की आवश्यकताओं को पूरा करने की आवश्यकता है, इसलिए इसमें ऑपरेटरों () का कार्यान्वयन है।

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

इस हैंडलर का उपयोग करने के लिए, हमें इस हस्ताक्षर के साथ asio_handler_invoke फ़ंक्शन को परिभाषित करने की आवश्यकता है:

 template <typename FunctionT, typename HandlerT> void asio_handler_invoke(FunctionT func, NdcDecorator<HandlerT> * ndcHandler) { NdcHolder ndcHolder(ndcHandler->ndc()); func(); } 

जैसा कि हम देख सकते हैं, कार्यान्वयन तुच्छ है: हम एनडीसी स्थापित करते हैं और हमारे हैंडलर को बुलाते हैं, सब कुछ सरल है।

अब हमें अपने फ़ंक्शन को कॉल करने के लिए asio को मजबूर करने की आवश्यकता है, क्योंकि नियमित हैंडलर अभी भी पुराने asio_handler_invoke फ़ंक्शन का उपयोग करके कहा जाएगा।
अतुल्यकालिक पढ़ने शुरू करने के एक उदाहरण पर विचार करें:

 mSocket->async_read_some(to_asio_buffer(mInputMsg), boost::bind(&server_connection::onRead, shared_from(this), placeholders::error, placeholders::bytes_transferred)); 

यहां हम बढ़ावा देने के लिए एक हैंडलर बनाते हैं :: बाइंड। हमारे संदर्भ को सेट करने के लिए, सजाए गए फ़ंक्शन का उपयोग करके हमारे NdcDecorator में बने हैंडलर को लपेटें :

 mSocket->async_read_some(to_asio_buffer(mInputMsg), decorate( boost::bind(&server_connection::onRead, shared_from(this), placeholders::error, placeholders::bytes_transferred))); 

जैसा कि हम देखते हैं, परिवर्तन महत्वपूर्ण नहीं है - अर्थात्, किसी अन्य फ़ंक्शन को कॉल करना, लेकिन यह फ़ंक्शन वह संदर्भ बनाता है जिसकी हमें आवश्यकता है और NDC सेट करता है:

 template <typename HandlerT> NdcDecorator<HandlerT> decorate(HandlerT handler, const std::string & ndc = log4cpp::NDC::get()) { return NdcDecorator<HandlerT>(handler, ndc); } 

कार्यान्वयन भी काफी तुच्छ है: दूसरा पैरामीटर डिफ़ॉल्ट रूप से सेट है - एनडीसी के वर्तमान मूल्य के बराबर। वर्तमान एनडीसी मान को पहले सेट किया जा सकता है (हमारे उदाहरण में, कनेक्शन बनने के तुरंत बाद ऐसा होता है - जब पहला एसिंक्रोनस शुरू होता है)।

हम एनडीसी के साथ क्लाइंट और सर्वर शुरू करते हैं

अब हम ndc (सर्वर) पैरामीटर से शुरू करते हैं:

 9179 INFO starting asynchronous write... <SID=1> 9179 INFO starting asynchronous accept... 9179 INFO write status: system:0, message: Success, bytes written: 4 <SID=1> 9179 INFO starting asynchronous timeout 00:00:00.765000 ... <SID=1> ... 9595 INFO read status: system:0, message: Success <SID=3> 9595 INFO answer from client readed: [GOODBYE] <SID=3> 9595 INFO timer status: system:0, message: Success <SID=65> 9595 INFO starting asynchronous read... <SID=65> 9598 INFO read status: system:0, message: Success <SID=12> 9598 INFO answer from client readed: [GOODBYE] <SID=12> 

सर्वर लॉग में, हम देखते हैं कि सभी ऑपरेशन वास्तव में मिश्रित हैं, लेकिन अब हम इसे देख सकते हैं। इसके अलावा, हम उपयोग कर सकते हैं, उदाहरण के लिए, हमारे द्वारा आवश्यक संचालन को फ़िल्टर करने के लिए grep:

 cat ndc_server.log | grep "<SID=50>" > 50.log 

 9199 INFO starting asynchronous write... <SID=50> 9199 INFO write status: system:0, message: Success, bytes written: 4 <SID=50> 9199 INFO starting asynchronous timeout 00:00:00.879000 ... <SID=50> 10079 INFO timer status: system:0, message: Success <SID=50> 10079 INFO starting asynchronous read... <SID=50> 10100 INFO read status: system:0, message: Success <SID=50> 10100 INFO answer from client readed: [GOODBYE] <SID=50> 

प्रयुक्त साहित्य की सूची:

• एसियो के नमूने - मैंने इसे जोड़ना आवश्यक समझा, क्योंकि यह इस लेख था जिसने मुझे इस समस्या को हल करने के लिए प्रेरित किया