एप्लिकेशन लॉगिंग के कुछ पैटर्न और विरोधी पैटर्न क्या हैं? [बन्द है]


66

मुझे हाल ही में हमारे बड़े उद्यम आवेदन के लिए एक क्षेत्र के मुद्दे की जांच करनी थी। मैं उन लॉग से भयभीत था जो मुझे समस्या को खोजने के प्रयास में कंघी करना था और दिन के अंत में लॉग्स ने बग को पहचानने / अलग करने में मदद नहीं की।

नोट: मैं समझता हूं कि सभी बग लॉग के माध्यम से खोजे जाने योग्य नहीं हैं। यह इस तथ्य को नहीं बदलता है कि लॉग भयानक हैं।

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

इसके बजाय, यह आकलन करने के लिए कि हम लॉगिंग मोर्चे पर कितना बुरा कर रहे हैं, मैं जानना चाहूंगा:

  1. कुछ दिशानिर्देशों , यदि कोई हो, जब किसी अनुप्रयोग के लिए लॉगिंग की बात आती है , विशेष रूप से बड़े अनुप्रयोग की।
  2. क्या कोई ऐसी परिपाटी है जिसका हमें पालन ​​करना चाहिए या विरोधी प्रतिमानों से हमें अवगत होना चाहिए?
  3. क्या यह ठीक करने के लिए एक महत्वपूर्ण बात है या इसे ठीक भी किया जा सकता है या सभी लॉग फाइलें बस विशाल हैं और आपको उनका विश्लेषण करने के लिए पूरक लिपियों की आवश्यकता है?

साइड नोट: हम log4j का उपयोग करते हैं।

जवाबों:


55

कुछ बिंदु जो मेरे अभ्यास उपयोगी साबित हुए:

  • अपने उत्पादन कोड में सभी लॉगिंग कोड रखें। उत्पादन में अधिक / कम विस्तृत लॉगिंग को सक्षम करने की क्षमता है, अधिमानतः प्रति सबसिस्टम और अपने प्रोग्राम को पुनरारंभ किए बिना।

  • grepआंखों के द्वारा पार्स करना आसान बनाते हैं । प्रत्येक पंक्ति की शुरुआत में कई सामान्य क्षेत्रों से चिपके रहते हैं। हर लाइन में समय, गंभीरता और सबसिस्टम को पहचानें। स्पष्ट रूप से संदेश तैयार करें। हर लॉग संदेश को उसके स्रोत कोड लाइन पर मैप करने के लिए आसान बनाएं।

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

लॉग की निगरानी और समस्या निवारण के लिए ज्यादातर आवश्यक हैं। अपने आप को एक समस्या निवारक के जूते में रखें और सोचें कि जब कुछ गलत हो रहा है या रात के मृतकों में आप किस तरह के लॉग करना चाहते हैं।


10
मुझे यह उत्तर पसंद है, लेकिन मैं यह जोड़ना चाहूंगा कि निर्णय बिंदुओं पर जो पसंद किया गया था उसे लॉग करना महत्वपूर्ण है। मैंने कई प्रणालियाँ देखी हैं जहाँ बहुत सारे कबाड़ को लॉग किया गया था लेकिन महत्वपूर्ण निर्णय नहीं लिए गए थे। तो लॉगिंग का 95% मूल रूप से बेकार है। इसके अलावा अनुरोध / प्रतिक्रिया प्रकार प्रणालियों के लिए यह सबसिस्टम द्वारा प्रति अनुरोध लॉग करने में सक्षम होना अधिक महत्वपूर्ण है।
केविन

4
+1। मुझे अपने आप को एक समस्या निवारक के जूते में रखने के बारे में पसंद है। ऐसा लगता है कि लॉग स्टेटमेंट में बहुत अधिक गुणवत्ता वाले संदेश होने चाहिए, फिर हम क्या कर रहे हैं ...
c_maker

1
यह ध्यान रखना महत्वपूर्ण है कि त्रुटि लॉगिंग को एप्रॉपिएट इवेंटलॉग के साथ-साथ एप्लिकेशन लॉग में भी लॉग इन किया जाना चाहिए।
स्टीवन एवर्स

2
@SnOrfus: लॉग्स को स्टोर करने के कई तरीके हैं, लेकिन सार यह है कि लॉग मैसेज को सिस्टम के दुर्घटनाग्रस्त होने के अंतिम समय तक उपलब्ध कराने की जरूरत है - जैसे विमान ब्लैक बॉक्स। यदि आप किसी भी प्रकार के बफरिंग का उपयोग करते हैं, तो इसे बायपास करने का विकल्प प्रदान करें / हर संदेश को फ्लश करें।
रवांग

1
@ रिग: दूसरी ओर, कई घर-निर्मित लॉगर ने किसी भी बफरिंग को लागू नहीं किया (और प्रत्येक संदेश को सावधानीपूर्वक फ्लश), बहुत खराब प्रदर्शन के लिए अग्रणी। यही कारण है कि इसे वैकल्पिक बनाया जाना चाहिए।
21

28

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

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

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

off
errors only
basic
detailed
everything

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

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

#define DEBUG_ERROR          1
#define DEBUG_BASIC          2
#define DEBUG_DETAIL         4
#define DEBUG_MSG_BASIC      8
#define DEBUG_MSG_POLL       16
#define DEBUG_MSG_STATUS     32
#define DEBUG_METRICS        64
#define DEBUG_EXCEPTION      128
#define DEBUG_STATE_CHANGE   256
#define DEBUG_DB_READ        512
#define DEBUG_DB_WRITE       1024
#define DEBUG_SQL_TEXT       2048
#define DEBUG_MSG_CONTENTS   4096

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

सॉफ्टवेयर आम तौर पर ERROR, BASIC, STATE_CHANGE और EXCEPTION के साथ काम करता है, लेकिन इसे डिबग डायलॉग (या रजिस्ट्री / आईएनआई / सीएफजी सेटिंग, जहां ये चीजें सेव हो जाती हैं) के माध्यम से फील्ड में बदला जा सकता है।

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

अंत में, आप नहीं चाहते कि आपका कोड स्वयं की समस्याएं उत्पन्न करे, इसलिए इतने दिनों या हफ्तों के बाद लॉग फ़ाइलों को शुद्ध करने के लिए एक टाइमर फ़ंक्शन में रखें (बस फ़ाइल निर्माण के समय और समय के बीच का अंतर देखें)। यह एक सर्वर ऐप के लिए ठीक है, जो हर समय चलता रहता है, क्लाइंट साइड ऐप पर आप किसी भी पुराने डेटा को शुरू करने के बाद प्राप्त कर सकते हैं। हम आम तौर पर 30 दिनों या उसके बाद शुद्ध करते हैं, एक सिस्टम पर लगातार इंजीनियर यात्राओं के बिना आप इसे लंबे समय तक छोड़ना चाह सकते हैं। जाहिर है यह आपकी लॉग फ़ाइलों के आकार पर भी निर्भर है।


1
+1 सामान्य उत्कृष्ट उत्तर में, लेकिन विशेष रूप से लॉग फ़ाइल में एप्लिकेशन आईडी और संस्करण जानकारी डालने के लिए, दुर्भाग्य से यह बहुत बार याद किया जाता है।
बाइनरी वॉरियर

27

लॉगिंग दिशानिर्देशों के लिए मेरा पसंदीदा सार्वजनिक संसाधन Apache JCL बेस्ट प्रैक्टिसेस हैं

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

एंटरप्राइज बेस्ट-प्रैक्टिस सिद्धांत मिडिलवेयर घटकों और टूलिंग पर लागू होते हैं जो "एंटरप्राइज़" स्तर के वातावरण में निष्पादित होने की उम्मीद है। ये मुद्दे अंतर्राष्ट्रीयकरण और गलती का पता लगाने के रूप में लॉगिंग से संबंधित हैं। एंटरप्राइज़ को अधिक प्रयास और योजना की आवश्यकता होती है, लेकिन उत्पादन स्तर प्रणालियों में दृढ़ता से प्रोत्साहित किया जाता है (यदि आवश्यक नहीं है)। विभिन्न कॉर्पोरेट उद्यमों / वातावरणों की अलग-अलग आवश्यकताएं होती हैं, इसलिए लचीला होना हमेशा मदद करता है ...

JCL को लक्षित करने के बावजूद, ये सामान्य रूप से लॉगिंग के लिए अपनाए जाने के लिए पर्याप्त सामान्य प्रतीत होते हैं।

  • लॉगिंग के लिए मेरा व्यक्तिगत "दिशानिर्देश" है कि डिबग स्तर पर, मैं अपने लॉग को कहानी की तरह पढ़ने के लिए समझने की कोशिश करता हूं - समझने योग्य तर्क और पर्याप्त (लेकिन अतिभारित नहीं) विवरण के साथ।

सबसे प्रसिद्ध विरोधी पैटर्न संभवतः "निगल अपवाद" है - बस इसके लिए वेब खोजें।

विशाल लॉगिंग फ़ाइलों के लिए, मेरे अभ्यास में यह ज्यादातर सामान्य मामला था। और हां, पूरक लिपियों के रूप में आप उन्हें कॉल करते हैं और / या चैंसॉ जैसे उपकरण भी मुझे सामान्य लगते हैं।

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

पुनश्च। विरोधी प्रतिमानों के बारे में, जो अन्य लोगों के दिमाग में आते हैं, वे हैं "बाढ़" और संवेदनहीन संदेश।

  • जब मैं कई पुनरावृत्तियों के साथ लूप से आने वाले समान संदेशों को देखता हूं, तो मैं इसे बाढ़ कहता हूं । मेरे लिए, बाढ़ काफी कष्टप्रद है जब मैं इसे स्रोत कोड में पता लगाता हूं। आमतौर पर इसमें सुधार के लिए कुछ कला की आवश्यकता होती है - क्योंकि, ठीक है, लूप के भीतर होने वाली चीजें दिलचस्प हो सकती हैं। जब मेरे पास इसे बेहतर बनाने का समय नहीं है, तो मैं कम से कम ऐसे संदेशों के लॉगिंग स्तर को कम से कम एक में बदलने की कोशिश करता हूं ताकि इसे फ़िल्टर करना आसान हो सके।

  • सेंसलेस मैसेज काफी लोकप्रिय कचरा लगता है। जब स्रोत कोड में पढ़ा जाता है तो ये हानिरहित दिखते हैं - मुझे लगता है कि किसी को डीबग आउटपुट के विश्लेषण के दर्द से गुजरना पड़ता है ...

    step #1
    step #2
    step #3
    

    ... उनके अंतर्निहित कुरूपता की गहराई से सराहना करने के लिए। स्रोत कोड स्तर पर इस तरह की समस्याओं का पता लगाने के लिए मेरा पसंदीदा उत्तराधिकार (मेरी पिछली परियोजनाओं में से एक में सहकर्मी द्वारा प्रस्तावित) लॉगिंग में उपयोग किए जाने वाले स्ट्रिंग लीटर में अंतरिक्ष प्रतीक घटनाओं की संख्या की गणना करना है। मेरे अनुभव में, शून्य स्थान मूल रूप से लॉगिंग स्टेटमेंट की गारंटी देता है, संवेदनहीन है, एक स्थान संभावित मुद्दे का एक अच्छा संकेतक भी है।


4
बाढ़ से बचने के लिए मैं आम तौर पर लूप के हेयूरिस्टिक्स इकट्ठा करता हूं और लूप के बाद इसे आउटपुट करता हूं। मतलब लूप में होने वाली कुछ भी दिलचस्प चीजों को एक चर (जैसे somethingSpecialHappenedCount) में संग्रहित किया जाना चाहिए और फिर लकड़हारे को आउटपुट देना चाहिए।
स्पोकाइक

@ अच्छा मुद्दा! एक चर में संग्रहीत करना वास्तव में बाढ़ से लड़ने के लिए मेरी व्यक्तिगत पसंदीदा चालों में से एक है
gnat

1
मैं लूप के समाप्त होने के बाद लॉग में ASCII- टेबल के रूप में लकड़हारे को सभी अलग-अलग काउंटरों का उत्पादन करता हूं ताकि उनकी तुलना आसानी से की जा सके। तालिका का विचार स्प्रिंग के StopWatch.prettyPrint () जनरेट से प्रेरित था । इसके अलावा, लॉग टेक्स्ट को पठनीय और प्रासंगिक बनाना अभी भी एक "कला" है जैसा कि पहले उत्तर में बताया गया है।
10

@ साइकाइक: (और @gnat) यह दिलचस्प है। तो मूल रूप से आप लॉगिंग के उद्देश्य से व्यवसायिक तर्क के लिए वास्तविक कोड जोड़ते हैं? मैंने ऐसा पहले कभी नहीं सुना या किया और यह सुनिश्चित नहीं किया कि मैं इसे अपने सहकर्मियों के लिए कैसे उचित ठहराऊंगा। मुझे डर है कि अगर हमने ऐसा करना शुरू कर दिया, तो हमारे कुछ डेवलपर्स स्रोत कोड को इस हद तक अव्यवस्थित कर देंगे कि व्यावसायिक तर्क जटिल और पढ़ने में कठिन हो जाए। बस एक बयान में प्रवेश करने से पहले से ही स्रोत बदसूरत लग रहा है।
c_maker

2
व्यापार तर्क के साथ लॉगिंग मिश्रण के बारे में आपकी बात @c_maker एक समर्पित प्रश्न के लायक है। व्यक्तिगत रूप से मेरे पास अभी तक इन मामलों के बारे में मजबूत राय नहीं है। सिद्धांत रूप में AOP के उपयोग से कुछ पृथक्करण सुधारों की कल्पना कर सकते हैं और iirc इस दृष्टिकोण के लिए व्यावहारिक अनुप्रयोग भी हैं। व्यवहार में, हालांकि, मैं "मिश्रित" दृष्टिकोण के साथ रहता हूं और अब तक मुझे इसके साथ कोई बड़ी समस्या नहीं थी। अव्यवस्था स्रोत कोड वास्तविक खतरा है लेकिन, फिर से, अभी तक मैं इसे कोडिंग के साथ बनाने में सक्षम था कोडिंग के साथ काफी "शांति"। इस कोर्स के लिए निश्चित प्रयास की आवश्यकता है।
gnat

11

केवल एक बार अपवाद लॉग इन करें!

सामान्य दर्द बिंदुओं में से एक जो मैंने देखा है वह एक अपवाद को लॉग और रीथ्रोइंग कर रहा है। परिणामस्वरूप, लॉग फ़ाइलों में कई स्टैक स्तरों पर एक ही अपवाद कई बार होता है।


5

यहाँ एक विरोधी प्रतिमान है: दो दर्जन "जनन-अक्षम्य" फ़ील्ड को डेटाबेस में तालिका में रखा जा सकता है ताकि कुछ भी अनुमान लगाने योग्य हो और फिर 88 (और गिनती) होने पर विभिन्न प्रकार के लॉग के लिए अलग-अलग एनम मान हो।


+1 - मैंने इसे देखा है। "एरर टेबल्स" जिसमें string1, string2, string3, string4, string5 जैसे कॉलम हैं, जहां सभी कॉलमों को समेटने से एक त्रुटि कोड उत्पन्न होगा जो किसी भी दस्तावेज में संदर्भित नहीं है। परिणाम लॉगिंग है जो भ्रमित और बेकार दोनों है; जिसे "3rd-party-एंटरप्राइज़-ऐप-विथ-कस्टम-डेवलपमेंट-डिबगिंग-नर्क" के रूप में भी जाना जाता है।
मॉर्गन हेरलॉकर

मेरे मामले में यह "हाथ से लुढ़का हुआ लॉगिंग सिस्टम है, जो किसी भी विचार के बिना वास्तव में लॉगिंग में शामिल है"
वेन मोलिना

4

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

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


2

घर के संचालन पक्ष से नोटों के जोड़े यहां:

1) सुनिश्चित करें कि लॉग स्थानीय रूप से कॉन्फ़िगर करने योग्य हैं, अधिमानतः एक उपकरण के साथ जो पाठ संपादक से अधिक भारी नहीं है। अधिकांश समय हम TRACE स्तर की लॉगिंग प्राप्त नहीं करना चाहते हैं, लेकिन हम इसे चालू करने में सक्षम होना पसंद करते हैं।

2) यदि संभव हो तो, सुनिश्चित करें कि लॉग एक पाठ संपादक की तुलना में भारी नहीं टूल के साथ पढ़ा जा सकता है। जब उत्पादन प्रणाली विफल हो रही हो तो एक विषम समय में टूल हंट पर जाने से कुछ नहीं होता।


1

वेब-एप्लिकेशन के साथ काम करने के अपने अनुभव से:

(और भंडारण पर विचार करना अब बहुत सस्ता है)

  • जितनी उपलब्ध हो (उतनी ही गति से) जानकारी के लिए लॉग ऑन करें।
  • मैं हमेशा अपने लॉग-स्ट्रिंग्स में DateTime.Now को शामिल करता हूं।
  • मैं हमेशा (यदि यह संभव है) कुछ विशिष्ट "कार्रवाई" की समय-अवधि लॉग करें।
  • अपने लॉग-स्ट्रिंग्स के साथ संगत रहें। चूंकि मैं हमेशा इस तरह के पैटर्न का उपयोग करता हूं:

    • "[जानकारी एक्स] [जानकारी वाई] [जानकारी जेड] [आदि]"

1

स्टैकट्रेस के अलावा, वर्तमान एप्लिकेशन स्थिति और इनपुट लॉग करें।

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

बेशक अधिक डेटा हमेशा बेहतर होता है लेकिन कम से कम ये दो सबसे आसान क्रैश के लिए एक अच्छी शुरुआत है।


3
"सॉफ्टवेयर नियतात्मक है" => हमेशा दुर्भाग्य से नहीं। उदाहरण के लिए समरूपता कीड़े पर विचार करें।
अस्तिलास
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.