आप किस चरण में ओओ में लॉगिंग और ट्रेसिंग जोड़ते हैं?

Question

मुझे आपकी रुचि है कि आपके विकास में कौन सा चरण लॉगिंग और/या आपके अनुप्रयोगों पर ट्रेसिंग जोड़ रहा है?

मैं नेट नेट और लॉग 4नेट (commons.logging के माध्यम से) के साथ काम कर रहा हूं। आम तौर पर विकास के लिए एक टीडीडी दृष्टिकोण लेते हुए हालांकि स्वीकार्य रूप से 100% नहीं, कभी-कभी मैं परीक्षण कवरेज के बिना बाहर निकलने के बारे में जानता हूं। मेरा आवेदन सभी सर्वर-साइड बैठते हैं, उदा। वेब सेवाएं, विंडोज सेवा जो बस से संदेशों का उपभोग करती है, एएसपीनेट एमवीसी बिजनेस एडमिन ऐप। आदि ..

मुझे अपने आवेदक सेवाओं में वर्णनात्मक लॉगर के साथ सजावटी तरीके मिल गईं .INFO "भंडार से केक प्राप्त करना"। कुछ काम .. "भंडार से 5 केक मिला।", और उसके बाद ऐप डैमिनिन को लॉगर करने के लिए एक अनचाहे एक्सपेटियन हैंडलर। अप्रत्याशित उत्तेजनाओं के लिए फाटल जो बबल अप करता है।

हालांकि मैं आमतौर पर विकास की शुरुआत के बजाय विकास के अंत के करीब और इसे लागू करने के अंत में समाप्त होता हूं और मेरे पास केवल एक दर्जन या दो हो सकते हैं। मुझे लगता है कि मैं किसी भी निम्न स्तर की कक्षाओं को शायद ही कभी सजाने के लिए करता हूं जैसे कि लॉगजर सामान के साथ आईसीकेआर रिपोजिटरी के कार्यान्वयन के रूप में यह व्यर्थ लगता है।

ट्रेसिंग के लिए, जो कॉन्फ़िगरेशन के माध्यम से स्विच किया गया है, मैं आईओसी फ्रेमवर्क का उपयोग करके विधि कॉल और इंस्टेंस सृजन को रोकने की सोच रहा हूं, और इसे भारी ट्रेस आबादी के बजाय ऑन-साइट परेशानी का ख्याल रखना चाहिए।

Answer 1

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

मैं प्रत्येक परत के भीतर भी दावा जोड़ता हूं, जहां मैं कर सकता हूं, और दावा विफलताओं को लॉग करता हूं।

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

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

प्रवेश के बारे में देखभाल करने के लिए मेरे तर्क आंशिक रूप से निम्नलिखित में समझाया गया है:

• Separate ‘debug’ and ‘release’ builds?
• Should one test internal implementation, or only test public behaviour?

जारी किया सॉफ्टवेयर में किसी भी बग को ठीक करने के लिए, मैं लॉग फ़ाइल पर निर्भर करते हैं; और यह भी सॉफ्टवेयर के बारे में सच है क्योंकि इसे विकसित किया जा रहा है।

---

तुमने कहा था,

मैं मैं शायद ही कभी इस तरह के लकड़हारा सामान के साथ ICakeRepository के कार्यान्वयन के रूप में किसी भी निचले स्तर की कक्षाओं को सजाने के रूप में यह व्यर्थ लगता है पाते हैं।

मैंने कहा,

मेरे सॉफ्टवेयर प्रत्येक परत के बीच एक अच्छी तरह से परिभाषित एपीआई के साथ परतों में है। मैं शुरुआत से उन एपीआई के लिए लॉगिंग को लागू करने ...

करते हैं मुझे लगता है कि मैं बेहतर समझाने था "परत" है, जो या अपने "निचले स्तर" वर्गों के रूप में ही नहीं हो सकता से मैं क्या मतलब है ।

उदाहरण के लिए, अपने सिस्टम निम्नलिखित परतों हो सकता है:

• यूआई
• व्यापार परत (जोड़ तोड़ डेटा के लिए नियम)
• डेटा एक्सेस परत
• डाटाबेस (डेटाबेस आई/ओ के लिए)

उस स्थिति में मेरे पास निम्न इंटरफेस या एपीआई होंगे, जो लॉगिंग के लायक हो सकते हैं:

• उपयोगकर्ता और यूआई के बीच (यानी। यूआई घटनाओं, माउस और कीबोर्ड)
यूआई और व्यापार परत के बीच
• ("विनम्र संवाद बॉक्स" देखें)
व्यापार परत और दाल
• दाल और डेटाबेस के बीच के बीच

वैकल्पिक रूप से सिस्टम दो सहकर्मी अंत-बिंदुओं को जोड़ने वाले घटकों की एक श्रृंखला हो सकता है (स्पष्ट रूप से "शीर्ष" और "नीचे" परतों के साथ)।

• जटिल नहीं (मुखौटा अंतर्निहित से अधिक आसान हो जाता है:

  किसी भी मामले में, मैं क्या लॉगिन कर रहा हूं एपीआई प्रत्येक घटक के सार्वजनिक मुखौटा है, जो कई कारणों से प्रवेश के लिए अच्छा है कि है/आंतरिक कार्यान्वयन)

• अच्छा कवरेज (यदि मैं पूरे मुखौटा को लॉग करता हूं, और यदि घटक में एकमात्र तरीका इसके मुखौटे के माध्यम से है, तो मुझे पता है कि मैंने घटक में जो कुछ भी किया है उसे लॉग किया है)
• अच्छी तरह से काम करता है Conway's Law: जब एक से अधिक घटकों के साथ एक सिस्टम डीबगिंग, प्रत्येक एक अलग टीम द्वारा विकसित , आवर्ती प्रश्नों में से एक है, "कौन सा घटक गलती पर है, और इसलिए किस टीम को इसे डीबग करने की आवश्यकता है?"

Answer 2

मैं यह नहीं कहूंगा कि "भंडार से केक प्राप्त करना" सर्वोत्तम फिटनेस जानकारी है। यह DEBUG या यहां तक ​​कि ट्रेस के लिए अधिक उपयुक्त है। आमतौर पर आप कार्यात्मक सामान लॉगिंग के लिए INFO का उपयोग करना चाहते हैं, उदा। "उपयोगकर्ता ए के लिए कोई केक नहीं छोड़े गए हैं"। गैर-कार्यात्मक सामान और तकनीकी प्रवाह कम तीव्रता IMHO के साथ होना चाहिए। मैं अपवाद लॉगिंग के लिए FATAL का उपयोग नहीं करता, जब तक आप उस बिंदु तक नहीं पहुंच जाते जब आवेदन पूरी तरह से मर जाता है .. यह FATAL को देखने में काफी उलझन में होगा और फिर सिस्टम अभी भी जीवित और लात मार रहा है। त्रुटि एक बेहतर विकल्प है, कभी-कभी चेतावनी भी निर्भर करती है कि अपवाद कितना बुरा है। एओपी इंटरसेप्टर के रूप में, पिछली बार मैंने चेक किया - ये सामान प्रदर्शन को बहुत प्रभावित करता है। यह ठंडा और सेक्सी अवधारणा है, लेकिन मेरे मामले में व्यावहारिक नहीं था, यह सुनिश्चित नहीं है कि यह एओपी के लाभों को समझाते हुए पुस्तकों और लेखों से डेमो और मामूली उदाहरणों से आगे हो। तो, मैं पूरी तरह से इस पर भरोसा करने से पहले दोबारा जांच करूँगा।

Answer 3

हम टीडीडी हैं इसलिए हम मूल रूप से अधिक लॉगिंग नहीं करते हैं। शायद शीर्ष स्तर के अपवाद हैंडलर और कुछ रणनीतिक स्थानों में।

Answer 4

लॉगिंग और ट्रेसिंग क्रॉस-कटिंग चिंताओं को होना चाहिए। यदि आप पहलू उन्मुख प्रोग्रामिंग का उपयोग कर रहे हैं तो आप किसी भी समय घोषणात्मक तरीके से उन्हें जोड़/हटा सकते हैं।