कनेक्ट / एक्सप्रेस में अनुरोध के संदर्भ को बनाए रखते हुए अतुल्यकालिक त्रुटियों को संभालना

जिन लोगों को नोड या जेएस पर अधिक या कम बड़ी वेब परियोजनाएं विकसित करनी थीं, वे शायद एसिंक्रोनस कॉल के अंदर होने वाली त्रुटियों से निपटने की समस्या का सामना कर रहे थे। यह समस्या आमतौर पर तुरंत सामने नहीं आती है, और जब आपके पास पहले से ही बहुत सारे लिखित कोड होते हैं जो "हैलो, वर्ल्ड!"

समस्या का सार

उदाहरण के लिए, एक साधारण कनेक्ट एप्लिकेशन लें:

var connect = require('connect'); var getName = function () { if (Math.random() > 0.5) { throw new Error('Can\'t get name'); } else { return 'World'; } }; var app = connect() .use(function (req, res, next) { try { var name = getName(); res.end('Hello, ' + name + '!'); } catch (e) { next(e); } }) .use(function (err, req, res, next) { res.end('Error: ' + err.message); }); app.listen(3000); 

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

अब इसे करने की कोशिश करते हैं, लेकिन getName फ़ंक्शन अतुल्यकालिक होगा:

 var connect = require('connect'); var getName = function (callback) { process.nextTick(function () { if (Math.random() > 0.5) { callback(new Error('Can\'t get name')); } else { callback(null, 'World'); } }); }; var app = connect() .use(function (req, res, next) { getName(function(err, name) { if (err) return next(err); res.end('Hello, ' + name + '!'); }); }) .use(function (err, req, res, next) { res.end('Error: ' + err.message); }); app.listen(3000); 

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

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

निर्णय

संस्करण 0.8.0 में शुरू, डोमेन नामक एक तंत्र Node.JS में दिखाई दिया है। यह आपको प्रक्रिया के विपरीत, निष्पादन संदर्भ को संरक्षित करते हुए, एसिंक्रोनस कॉल के अंदर त्रुटियों को पकड़ने की अनुमति देता है। ('uncaughtException')। मुझे लगता है कि यहां डोमेन पर प्रलेखन को फिर से बेचना कोई मतलब नहीं है। इसके संचालन का तंत्र काफी सरल है, इसलिए मैं तुरंत कनेक्ट / एक्सप्रेस के लिए सार्वभौमिक त्रुटि हैंडलर के एक विशिष्ट कार्यान्वयन पर जाऊंगा।

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

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

इस उद्देश्य के लिए, मैंने कनेक्ट / एक्सप्रेस के लिए एक छोटा मिडलवेयर मॉड्यूल लिखा जो इस समस्या को हल करता है। मॉड्यूल GitHub और npm पर उपलब्ध है।

उपयोग का उदाहरण:

 var connect = require('connect'), connectDomain = require('connect-domain'); var app = connect() .use(connectDomain()) .use(function(req, res){ if (Math.random() > 0.5) { throw new Error('Simple error'); } setTimeout(function() { if (Math.random() > 0.5) { throw new Error('Asynchronous error from timeout'); } else { res.end('Hello from Connect!'); } }, 1000); }) .use(function(err, req, res, next) { res.end(err.message); }); app.listen(3000); 

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

 var connect = require('connect'), connectDomain = require('connect-domain'); var app = connect() .use(connectDomain()) .use(function(req, res){ if (Math.random() > 0.5) { throw new Error('Simple error'); } setTimeout(function() { if (Math.random() > 0.5) { process.nextTick(function() { throw new Error('Asynchronous error from process.nextTick'); }); } else { res.end('Hello from Connect!'); } }, 1000); }) .use(function(err, req, res, next) { res.end(err.message); }); app.listen(3000); 

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