C ++ एप्लिकेशन की निगरानी करना

Question

हम एक नया केंद्रीकृत निगरानी समाधान (जेनॉस) लागू कर रहे हैं। सर्वर, नेटवर्किंग और जावा प्रोग्राम को शामिल करना SNMP और JMX के साथ सीधा है।

हालांकि, सवाल यह है कि बड़े, विषम (Solaris x86, RHEL Linux, Windows) वातावरणों में कस्टम C ++ अनुप्रयोगों की निगरानी और प्रबंधन के लिए सर्वोत्तम अभ्यास क्या हैं?

मेरे द्वारा देखी जाने वाली संभावनाएँ हैं:

1. नेट एसएनएमपी

• लाभ

1. प्रत्येक सर्वर पर एकल, केंद्रीय डेमॉन
2. प्रसिद्ध मानक
3. निगरानी समाधान में आसान एकीकरण
4. हम अपने सर्वर पर पहले से ही नेट SNMP डेमॉन चलाते हैं

नुकसान:

1. जटिल कार्यान्वयन (MIBs, नेट SNMP पुस्तकालय)
2. सी ++ डेवलपर्स के लिए पेश करने के लिए नई तकनीक

rsyslog

• लाभ

1. प्रत्येक सर्वर पर एकल, केंद्रीय डेमॉन
2. प्रसिद्ध मानक
3. निगरानी समाधानों में अज्ञात एकीकरण (मुझे पता है कि वे पाठ के आधार पर अलर्ट कर सकते हैं, लेकिन टेलीमेट्री जैसे मेमोरी उपयोग, कतार की गहराई, थ्रेड क्षमता, आदि भेजने के लिए यह कितना अच्छा काम करेगा)
4. सरल कार्यान्वयन

नुकसान:

1. संभव एकीकरण मुद्दों
2. सी ++ डेवलपर्स के लिए कुछ नई तकनीक
3. यदि हम निगरानी विक्रेताओं को स्विच करते हैं तो संभव पोर्टिंग समस्याएँ
4. संभवतः इसमें एक तदर्थ संचार प्रोटोकॉल (या RFC5424 संरचित डेटा का उपयोग करना शामिल है; मुझे नहीं पता कि ज़ेनॉस कस्टम ज़ेनपैक कोडिंग के बिना समर्थन करता है)

एंबेडेड JMX (एक JVM एम्बेड करें और JNI का उपयोग करें)

• लाभ

1. जावा और C ++ दोनों के लिए लगातार प्रबंधन इंटरफ़ेस
2. प्रसिद्ध मानक
3. निगरानी समाधान में आसान एकीकरण
4. कुछ हद तक सरल कार्यान्वयन (हम पहले से ही आज अन्य उद्देश्यों के लिए करते हैं)

नुकसान:

1. जटिलता (जेएनआई, मूल सी ++ और जावा के बीच थरथराने वाली परत, मूल रूप से प्रबंधन कोड को दो बार लिखना)
2. संभव स्थिरता की समस्याओं
3. प्रत्येक प्रक्रिया में एक जेवीएम की आवश्यकता होती है, और अधिक मेमोरी का उपयोग करते हुए
4. JMX C ++ डेवलपर्स के लिए नई तकनीक है
5. प्रत्येक प्रक्रिया का अपना JMX पोर्ट होता है (हम प्रत्येक मशीन पर बहुत सारी प्रक्रियाएँ चलाते हैं)

स्थानीय JMX डेमॉन, प्रक्रियाएं इससे जुड़ती हैं

• लाभ

1. प्रत्येक सर्वर पर एकल, केंद्रीय डेमॉन
2. जावा और C ++ दोनों के लिए लगातार प्रबंधन इंटरफ़ेस
3. प्रसिद्ध मानक
4. निगरानी समाधान में आसान एकीकरण

नुकसान:

1. जटिलता (मूल रूप से प्रबंधन कोड को दो बार लिखना)
2. इस तरह के डेमॉन को खोजने या लिखने की जरूरत है
3. जेएमएक्स डेमॉन और सी ++ प्रक्रिया के बीच एक प्रोटोकॉल की आवश्यकता है
4. JMX C ++ डेवलपर्स के लिए नई तकनीक है

कोडमेश JunC ++ आयन

• लाभ

1. जावा और C ++ दोनों के लिए लगातार प्रबंधन इंटरफ़ेस
2. प्रसिद्ध मानक
3. निगरानी समाधान में आसान एकीकरण
4. साझा JVM मोड में चलने पर प्रत्येक सर्वर पर एकल, केंद्रीय डेमॉन
5. कुछ सरल कार्यान्वयन (कोड पीढ़ी की आवश्यकता है)

नुकसान:

1. जटिलता (कोड पीढ़ी, अनुमानित कोड का उत्पादन करने के लिए GUI और ट्विकिंग के कई दौर की आवश्यकता होती है)
2. संभव जेएनआई स्थिरता समस्याओं
3. प्रत्येक प्रक्रिया में एक JVM की आवश्यकता होती है, और अधिक मेमोरी (एम्बेडेड मोड में) का उपयोग करते हुए
4. सोलारिस x86 का समर्थन नहीं करता (डील ब्रेकर)
5. यहां तक ​​कि अगर यह सोलारिस x86 का समर्थन करता है, तो संभावित कंपाइलर संगतता समस्याएं हैं (हम सोलिसिस के साथ एसटीएलपॉर्ट और फोर्टे के विषम संयोजन का उपयोग करते हैं।
6. एम्बेडेड मोड में चलने पर प्रत्येक प्रक्रिया का अपना JMX पोर्ट होता है (हम प्रत्येक मशीन पर बहुत सारी प्रक्रियाएँ चलाते हैं)
7. संभवतः गैर-सी ++ प्रक्रियाओं (?) के लिए एक साझा JMX सर्वर को शामिल नहीं करता है

क्या कुछ यथोचित मानकीकृत, सरल समाधान मुझे याद आ रहा है?

किसी अन्य उचित समाधान को देखते हुए, इनमें से कौन सा समाधान आमतौर पर कस्टम C ++ कार्यक्रमों के लिए उपयोग किया जाता है?

मेरी आंत महसूस करती है कि नेट SNMP है कि लोग ऐसा कैसे करते हैं, लेकिन मैं निर्णय लेने से पहले अन्य इनपुट और अनुभव पसंद करूंगा।

Answer 1

मैं ज़ेनॉस से सुपर परिचित नहीं हूं, लेकिन जब मैं इस तरह की चीज़ों के लिए नगिओस का इस्तेमाल करता था तो हम ग / c ++ प्रक्रिया को सॉकेट पर सुनते थे और एक कस्टम नगिओस प्लगइन लिखते थे जो नैदानिक ​​और स्थिति की जानकारी को सौंप देगा।

पहला कदम यह है कि आप अपनी प्रक्रिया को सुनने के लिए जिस लिब का इस्तेमाल करना चाहते हैं, उसे चुनें। C ++ सॉकेट लाइब्रेरी जैसी कोई चीज उसके लिए क्या करेगी। वहाँ कुछ भी जटिल नहीं है .. बस इस प्रक्रिया को सुनें।

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

वहाँ बहुत अधिक परिष्कृत सामान आप कर सकते हैं लेकिन विचार काफी सरल है। आप वस्तुओं के भीतर कूटबद्ध होने वाले कोड सुनने की प्रक्रिया के अपने छोटे-छोटे परिवाद लिख सकते हैं और अपने कस्टम c ++ सामान को मानकीकृत तरीके से खींच सकते हैं जब भी आप एक (या सभी) अपने निष्पादनों का निर्माण करते हैं

मेरी समझ से ज़ेनॉस भी ऐसा कर सकता है ।

संभवतः जब से ज़ेनॉस अजगर है, तब आप अपने कस्टम प्लगइन को इसके लिए कुछ सुनेंगे जैसे कि अपने सुनने वाले सी ++ निष्पादन योग्य से कनेक्ट करने के लिए।

Answer 2

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

खिड़कियों पर आप परफ़ॉर्म का उपयोग करके बहुत कुछ कर सकते हैं, यहां तक ​​कि दूरस्थ रूप से या एक ही काउंटर से जुड़ने के लिए WMI का उपयोग कर सकते हैं, और कार्रवाई करने के लिए उस पर (wmi में) कुछ स्वचालन कर सकते हैं।

Answer 3

मैं इस पर उठा रहा हूं क्योंकि हम हाल ही में आपके जैसी ही प्रक्रिया से गुजरे थे: हम एक हल्के, गैर-अवरोधक, खुले स्रोत वाले समाधान की तलाश कर रहे थे जो सी / सी ++ सेवाओं के भीतर से मेट्रिक्स को उजागर करने और बाद में दूरस्थ निगरानी की अनुमति देता है ( हमारे पास लगभग ~ 3000) है।

एसएनएमपी निकटतम आया लेकिन स्रोत और निगरानी प्रणाली में एकीकरण एक दर्द है और हमारे वास्तविक समय की प्रक्रियाओं के लिए उपयुक्त नहीं है।

अंत में, हमने CMX नामक एक नया समाधान विकसित करने का निर्णय लिया जो साझा मेमोरी तकनीक का उपयोग करता है और इसे ओपन-सोर्स बनाता है। आप यहाँ यह बाहर की जाँच कर सकते हैं: www.cern.ch/cmx ।

Answer 4

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

यह सेटअप मेट्रिक्स एकत्रीकरण या रिपोर्टिंग के लिए विफलता का कोई एकल बिंदु नहीं है (जैसा कि समय आधारित एकत्रीकरण स्वयं नोड्स पर होता है और रिपोर्टिंग एकत्रीकरण एक वितरित ग्रेफाइट क्लस्टर (या होस्ट किए गए ग्रेफाइट) में होता है।

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

Answer 5

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

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

उस सभी ने कहा, मैंने कई स्थानों पर देखा है जहां एसएमएनपी का उपयोग किया जाता है, और स्पष्ट रूप से, मैं एक कारण नहीं देख सकता हूं कि आप इसका उपयोग क्यों नहीं करेंगे - खासकर यदि आप पूरी तरह से विषम वातावरण में चल रहे हैं।