जावास्क्रिप्ट वैश्विक घटना तंत्र


351

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


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

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

2
अपवाद js.com यह कार्यक्षमता प्रदान करता है और इसकी "गार्ड" कार्यक्षमता के साथ केवल अपरिभाषित कार्यक्षमता से संबंधित त्रुटियों को पकड़ने के लिए taylored जा सकता है।
स्टीवन वेक्सलर

जवाबों:


193

क्या यह आपकी मदद करता है:

<script type="text/javascript">
window.onerror = function() {
    alert("Error caught");
};

xxx();
</script>

मुझे यकीन नहीं है कि यह कैसे फ्लैश त्रुटियों को संभालती है ...

अपडेट: यह ओपेरा में काम नहीं करता है, लेकिन मैं ड्रैगनफली को अभी हैक कर रहा हूं, यह देखने के लिए कि इसे क्या मिलता है। इस सवाल से आया ड्रैगनफली को हैक करने का सुझाव:

मिमिक विंडो। जावास्क्रिप्ट का उपयोग करके ओपेरा में onerror


3
संदेश के अतिरिक्त, file_loc, line_no params यह मेरे लिए करना चाहिए। धन्यवाद!

1
क्या मैं सही ढंग से समझता हूं कि यह कोड किसी भी मौजूदा त्रुटि हैंडलर को ओवरराइड करता है?
मार्स रॉबर्टसन

@MarsRobertson No.
atilkan

@atilkan window.onerror = function() { alert(42) };अब जवाब में कोड: window.onerror = function() { alert("Error caught"); };नहीं overriden, मैं अभी भी अनिश्चित हूँ ..
मंगल रॉबर्ट्सन

@ मार्स रॉबर्टसन मैं समझता हूं। यह शायद ओवरराइट करता है। हाँ, यह करता है, बस परीक्षण किया। AddEventListener का उपयोग करना बेहतर होगा।
atilkan

647

कैसे अनवांटेड जावास्क्रिप्ट एरर्स को कैच करें

window.onerrorइवेंट हैंडलर की तरह ईवेंट असाइन करें :

<script type="text/javascript">
window.onerror = function(msg, url, line, col, error) {
   // Note that col & error are new to the HTML 5 spec and may not be 
   // supported in every browser.  It worked for me in Chrome.
   var extra = !col ? '' : '\ncolumn: ' + col;
   extra += !error ? '' : '\nerror: ' + error;

   // You can view the information in an alert to see things working like this:
   alert("Error: " + msg + "\nurl: " + url + "\nline: " + line + extra);

   // TODO: Report this error via ajax so you can keep track
   //       of what pages have JS issues

   var suppressErrorAlert = true;
   // If you return true, then error alerts (like in older versions of 
   // Internet Explorer) will be suppressed.
   return suppressErrorAlert;
};
</script>

जैसा कि कोड में टिप्पणी की गई है, यदि रिटर्न का मान window.onerrorहै trueतो ब्राउज़र को एक चेतावनी संवाद दिखाना चाहिए।

Window.onerror इवेंट फायर कब होता है?

संक्षेप में, घटना को तब उठाया जाता है जब या तो 1.) एक अनकहा अपवाद होता है या 2.) एक संकलन समय त्रुटि होती है।

अपवाद नहीं

  • "कुछ संदेश" फेंकें
  • call_something_undefined ();
  • cross_origin_iframe.contentWindow.document ;, एक सुरक्षा अपवाद

संकलित त्रुटि

  • <script>{</script>
  • <script>for(;)</script>
  • <script>"oops</script>
  • setTimeout("{", 10);, यह एक स्क्रिप्ट के रूप में पहले तर्क को संकलित करने का प्रयास करेगा

ब्राउज़र्स window.onerror का समर्थन करते हैं

  • क्रोम 13+
  • फ़ायरफ़ॉक्स 6.0+
  • इंटरनेट एक्सप्लोरर 5.5+
  • ओपेरा 11.60+
  • सफारी 5.1+

स्क्रीनशॉट:

परीक्षण पृष्ठ पर इसे जोड़ने के बाद कार्रवाई में ऊपर दिए गए ओनर कोड का उदाहरण:

<script type="text/javascript">
call_something_undefined();
</script>

जावास्क्रिप्ट अलर्ट त्रुटि सूचना दिखा रही है जो window.onerror ईवेंट द्वारा विस्तृत है

AJAX त्रुटि रिपोर्टिंग के लिए उदाहरण

var error_data = {
    url: document.location.href,
};

if(error != null) {
    error_data['name'] = error.name; // e.g. ReferenceError
    error_data['message'] = error.line;
    error_data['stack'] = error.stack;
} else {
    error_data['msg'] = msg;
    error_data['filename'] = filename;
    error_data['line'] = line;
    error_data['col'] = col;
}

var xhr = new XMLHttpRequest();

xhr.open('POST', '/ajax/log_javascript_error');
xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
xhr.setRequestHeader('Content-Type', 'application/json');
xhr.onload = function() {
    if (xhr.status === 200) {
        console.log('JS error logged');
    } else if (xhr.status !== 200) {
        console.error('Failed to log JS error.');
        console.error(xhr);
        console.error(xhr.status);
        console.error(xhr.responseText);
    }
};
xhr.send(JSON.stringify(error_data));

JSFiddle:

https://jsfiddle.net/nzfvm44d/

संदर्भ:


3
फ़ायरफ़ॉक्स का उल्लेख करने योग्य मूल्य throwमैन्युअल रूप से बनाए जाने पर त्रुटि संदेश वापस नहीं देता है। stackoverflow.com/questions/15036165/…
सेबास

2
बहुत बढ़िया जवाब। आप JSNLog जैसे पैकेज के साथ "इस त्रुटि की रिपोर्ट अजाक्स के माध्यम से" लागू कर सकते हैं, जो आपके लिए अजाक्स और सर्वर साइड लॉगिंग करता है।
user1147862

4
इस उत्तर के अलावा, मैंने गलत ऑब्जेक्ट को जोड़ा ताकि मुझे स्टैक ट्रेस मिल सके। stackoverflow.com/a/20972210/511438 । अब मैं अधिक प्रतिक्रिया के साथ विकसित कर सकता हूं क्योंकि मेरी देव त्रुटियां पृष्ठ के शीर्ष पर एक बॉक्स के रूप में दिखाई देती हैं (जैसा कि मैंने इसे बनाया है)।
वलमास

क्या अपने ऑनरियर कार्यान्वयन को एक और अधिक त्रुटियों को फेंकने के लिए अपने ऑनरोर () को रोकने के लिए एक कोशिश-पकड़ने (अनदेखा) ब्लॉक में पैक करना बेहतर नहीं होगा? (ऐसा नहीं है कि यह यहाँ मामला है, लेकिन सिर्फ यकीन करने के लिए)
पीटर डी ब्यू

1
@ super1ha1 क्या आप एक jsfiddle प्रदान कर सकते हैं? मुझे नहीं लगता कि ब्राउज़र एक ब्रेकिंग परिवर्तन को पेश करेगा जहां ऑनरर इवेंट हैंडलर फायरिंग की घटनाओं को रोकता है। आप इस jsfiddle को onerror हैंडलर को काम करते हुए देखने की कोशिश कर सकते हैं: jsfiddle.net/nzfvm44d यह अभी भी मेरे लिए Chrome संस्करण 62.0.3202.94 (आधिकारिक बिल्ड) (64-बिट) में काम करता है।
सैम

39

परिष्कृत त्रुटि से निपटने

यदि आपकी त्रुटि हैंडलिंग बहुत परिष्कृत है और इसलिए वह स्वयं एक त्रुटि फेंक सकता है, तो यह इंगित करने के लिए एक ध्वज जोड़ना उपयोगी है कि क्या आप पहले से ही "errorHandling-Mode" में हैं। इस तरह:

var appIsHandlingError = false;

window.onerror = function() {
    if (!appIsHandlingError) {
        appIsHandlingError = true;
        handleError();
    }
};

function handleError() {
    // graceful error handling
    // if successful: appIsHandlingError = false;
}

अन्यथा आप अपने आप को एक अनंत लूप में पा सकते हैं।


29
या अधिक विफल-सुरक्षित तरीका handleErrorविधि के आसपास की कोशिश-कैच का उपयोग करना होगा ।
Aidiakapi

8
आप एरर हैंडलिंग में ansynchronous call होने पर आप try catch का उपयोग नहीं कर सकते हैं। तो वह समाधान है ई ई अच्छा समाधान बने रहें
Emrys Myrooin

@EmrysMyrooin अभी भी यह त्रुटि से एक सिंक या एक async लूप का कारण होगा और शायद प्रयोग करने योग्य स्टैक जानकारी के बिना क्रैश।
inf3rno

1
मुझे लगता है कि ध्वज को किसी बिंदु पर रीसेट किया जाना चाहिए, है ना? मेरा मानना ​​है कि यदि कोई बड़ा हो तो हमें एक कोशिश / पकड़ की आवश्यकता है, और सुनिश्चित करें कि ऑनरर विधि को छोड़ने से पहले ध्वज को ठीक से रीसेट किया जाए। अन्यथा, केवल एक त्रुटि को संभाला जाएगा।
सीबी

23

Atatus आज़माएं जो आधुनिक वेब ऐप्स के लिए उन्नत त्रुटि ट्रैकिंग और वास्तविक उपयोगकर्ता निगरानी प्रदान करता है।

https://www.atatus.com/

मुझे समझाएं कि स्टैकट्रैक्स कैसे प्राप्त करें जो सभी ब्राउज़रों में यथोचित रूप से पूर्ण हैं।

जावास्क्रिप्ट को संभालने में त्रुटि

मॉडर्न क्रोम और ओपेरा, एररइवेंट के लिए HTML 5 ड्राफ्ट स्पेस का पूरी तरह से समर्थन करते हैं और window.onerror । इन दोनों ब्राउज़रों में आप या तो उपयोग कर सकते हैं window.onerror, या 'त्रुटि' घटना को ठीक से बाँध सकते हैं :

// Only Chrome & Opera pass the error object.
window.onerror = function (message, file, line, col, error) {
    console.log(message, "from", error.stack);
    // You can send data to your server
    // sendError(data);
};
// Only Chrome & Opera have an error attribute on the event.
window.addEventListener("error", function (e) {
    console.log(e.error.message, "from", e.error.stack);
    // You can send data to your server
    // sendError(data);
})

दुर्भाग्य से फ़ायरफ़ॉक्स, सफारी और IE अभी भी आसपास हैं और हमें उनका भी समर्थन करना होगा। जैसा कि स्टैकट्रेस उपलब्ध नहीं है, window.onerrorहमें थोड़ा और काम करना होगा।

यह पता चला है कि त्रुटियों से स्टैकट्रैक्स प्राप्त करने के लिए हम एक ही चीज कर सकते हैं कि हमारे सभी कोड को एक try{ }catch(e){ }ब्लॉक में लपेटें और फिर देखेंe.stack । हम एक फ़ंक्शन के साथ प्रक्रिया को कुछ आसान बना सकते हैं जिसे रैप कहा जाता है जो एक फ़ंक्शन लेता है और अच्छी त्रुटि से निपटने के साथ एक नया फ़ंक्शन देता है।

function wrap(func) {
    // Ensure we only wrap the function once.
    if (!func._wrapped) {
        func._wrapped = function () {
            try{
                func.apply(this, arguments);
            } catch(e) {
                console.log(e.message, "from", e.stack);
                // You can send data to your server
                // sendError(data);
                throw e;
            }
        }
    }
    return func._wrapped;
};

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

वैश्विक परिभाषा को बदलकर addEventListenerताकि यह स्वचालित रूप से कॉलबैक को लपेटे हम स्वचालित रूप से सम्मिलित कर सकते हैंtry{ }catch(e){ } अधिकांश कोड के आसपास । इससे मौजूदा कोड काम करना जारी रखता है, लेकिन उच्च गुणवत्ता वाले अपवाद ट्रैकिंग को जोड़ता है।

var addEventListener = window.EventTarget.prototype.addEventListener;
window.EventTarget.prototype.addEventListener = function (event, callback, bubble) {
    addEventListener.call(this, event, wrap(callback), bubble);
}

हमें यह भी सुनिश्चित करने की आवश्यकता है कि removeEventListenerकाम करता रहे। फिलहाल ऐसा नहीं होगा क्योंकि तर्क addEventListenerबदल दिया गया है। फिर से हमें केवल prototypeऑब्जेक्ट पर इसे ठीक करने की आवश्यकता है :

var removeEventListener = window.EventTarget.prototype.removeEventListener;
window.EventTarget.prototype.removeEventListener = function (event, callback, bubble) {
    removeEventListener.call(this, event, callback._wrapped || callback, bubble);
}

अपने बैकएंड में त्रुटि डेटा संचारित करें

आप निम्नानुसार छवि टैग का उपयोग करके त्रुटि डेटा भेज सकते हैं

function sendError(data) {
    var img = newImage(),
        src = 'http://yourserver.com/jserror&data=' + encodeURIComponent(JSON.stringify(data));

    img.crossOrigin = 'anonymous';
    img.onload = function success() {
        console.log('success', data);
    };
    img.onerror = img.onabort = function failure() {
        console.error('failure', data);
    };
    img.src = src;
}

अस्वीकरण: मैं https://www.atatus.com/ पर एक वेब डेवलपर हूं ।


आपका server.com/jserror क्या है ? REST, वेब सेवा, Wcf सेवा ? बैकएंड के बारे में कोई सरल?
किकिनीत

यदि आप js त्रुटियों को उपयोगकर्ता ब्राउज़र से अपने सर्वर पर भेजना चाहते हैं। http://yourserver.comप्राप्त करने और संग्रहीत करने के लिए आपको अपना बैकेंड ( ) लिखना होगा । यदि आप atatus.com चुनते हैं , तो आपको कुछ भी करने की आवश्यकता नहीं है। बस अपने पेज में स्क्रिप्ट की दो लाइनें शामिल करें।
फेजर खान

18

ऐसा लगता है कि window.onerrorसभी संभावित त्रुटियों तक पहुँच प्रदान नहीं करता है। विशेष रूप से यह अनदेखा करता है:

  1. <img> लोडिंग त्रुटियां (प्रतिक्रिया> = 400)।
  2. <script> लोडिंग त्रुटियां (प्रतिक्रिया> = 400)।
  3. वैश्विक त्रुटियां यदि आपके ऐप में कई अन्य पुस्तकालय भी हैं, तो भी हेरफेर कर सकते हैं window.onerror , तो एक अज्ञात तरीके ( , कोणीय, आदि) में ।
  4. शायद कई मामलों में मैं अब (iframes, स्टैक ओवरफ्लो, आदि) की खोज के बाद नहीं चला।

यहां एक स्क्रिप्ट की शुरुआत है जो इन त्रुटियों में से कई को पकड़ती है, ताकि आप विकास के दौरान अपने ऐप में अधिक मजबूत डिबगिंग जोड़ सकें।

(function(){

/**
 * Capture error data for debugging in web console.
 */

var captures = [];

/**
 * Wait until `window.onload`, so any external scripts
 * you might load have a chance to set their own error handlers,
 * which we don't want to override.
 */

window.addEventListener('load', onload);

/**
 * Custom global function to standardize 
 * window.onerror so it works like you'd think.
 *
 * @see http://www.quirksmode.org/dom/events/error.html
 */

window.onanyerror = window.onanyerror || onanyerrorx;

/**
 * Hook up all error handlers after window loads.
 */

function onload() {
  handleGlobal();
  handleXMLHttp();
  handleImage();
  handleScript();
  handleEvents();
}

/**
 * Handle global window events.
 */

function handleGlobal() {
  var onerrorx = window.onerror;
  window.addEventListener('error', onerror);

  function onerror(msg, url, line, col, error) {
    window.onanyerror.apply(this, arguments);
    if (onerrorx) return onerrorx.apply(null, arguments);
  }
}

/**
 * Handle ajax request errors.
 */

function handleXMLHttp() {
  var sendx = XMLHttpRequest.prototype.send;
  window.XMLHttpRequest.prototype.send = function(){
    handleAsync(this);
    return sendx.apply(this, arguments);
  };
}

/**
 * Handle image errors.
 */

function handleImage() {
  var ImageOriginal = window.Image;
  window.Image = ImageOverride;

  /**
   * New `Image` constructor. Might cause some problems,
   * but not sure yet. This is at least a start, and works on chrome.
   */

  function ImageOverride() {
    var img = new ImageOriginal;
    onnext(function(){ handleAsync(img); });
    return img;
  }
}

/**
 * Handle script errors.
 */

function handleScript() {
  var HTMLScriptElementOriginal = window.HTMLScriptElement;
  window.HTMLScriptElement = HTMLScriptElementOverride;

  /**
   * New `HTMLScriptElement` constructor.
   *
   * Allows us to globally override onload.
   * Not ideal to override stuff, but it helps with debugging.
   */

  function HTMLScriptElementOverride() {
    var script = new HTMLScriptElement;
    onnext(function(){ handleAsync(script); });
    return script;
  }
}

/**
 * Handle errors in events.
 *
 * @see http://stackoverflow.com/questions/951791/javascript-global-error-handling/31750604#31750604
 */

function handleEvents() {
  var addEventListenerx = window.EventTarget.prototype.addEventListener;
  window.EventTarget.prototype.addEventListener = addEventListener;
  var removeEventListenerx = window.EventTarget.prototype.removeEventListener;
  window.EventTarget.prototype.removeEventListener = removeEventListener;

  function addEventListener(event, handler, bubble) {
    var handlerx = wrap(handler);
    return addEventListenerx.call(this, event, handlerx, bubble);
  }

  function removeEventListener(event, handler, bubble) {
    handler = handler._witherror || handler;
    removeEventListenerx.call(this, event, handler, bubble);
  }

  function wrap(fn) {
    fn._witherror = witherror;

    function witherror() {
      try {
        fn.apply(this, arguments);
      } catch(e) {
        window.onanyerror.apply(this, e);
        throw e;
      }
    }
    return fn;
  }
}

/**
 * Handle image/ajax request errors generically.
 */

function handleAsync(obj) {
  var onerrorx = obj.onerror;
  obj.onerror = onerror;
  var onabortx = obj.onabort;
  obj.onabort = onabort;
  var onloadx = obj.onload;
  obj.onload = onload;

  /**
   * Handle `onerror`.
   */

  function onerror(error) {
    window.onanyerror.call(this, error);
    if (onerrorx) return onerrorx.apply(this, arguments);
  };

  /**
   * Handle `onabort`.
   */

  function onabort(error) {
    window.onanyerror.call(this, error);
    if (onabortx) return onabortx.apply(this, arguments);
  };

  /**
   * Handle `onload`.
   *
   * For images, you can get a 403 response error,
   * but this isn't triggered as a global on error.
   * This sort of standardizes it.
   *
   * "there is no way to get the HTTP status from a 
   * request made by an img tag in JavaScript."
   * @see http://stackoverflow.com/questions/8108636/how-to-get-http-status-code-of-img-tags/8108646#8108646
   */

  function onload(request) {
    if (request.status && request.status >= 400) {
      window.onanyerror.call(this, request);
    }
    if (onloadx) return onloadx.apply(this, arguments);
  }
}

/**
 * Generic error handler.
 *
 * This shows the basic implementation, 
 * which you could override in your app.
 */

function onanyerrorx(entity) {
  var display = entity;

  // ajax request
  if (entity instanceof XMLHttpRequest) {
    // 400: http://example.com/image.png
    display = entity.status + ' ' + entity.responseURL;
  } else if (entity instanceof Event) {
    // global window events, or image events
    var target = entity.currentTarget;
    display = target;
  } else {
    // not sure if there are others
  }

  capture(entity);
  console.log('[onanyerror]', display, entity);
}

/**
 * Capture stuff for debugging purposes.
 *
 * Keep them in memory so you can reference them
 * in the chrome debugger as `onanyerror0` up to `onanyerror99`.
 */

function capture(entity) {
  captures.push(entity);
  if (captures.length > 100) captures.unshift();

  // keep the last ones around
  var i = captures.length;
  while (--i) {
    var x = captures[i];
    window['onanyerror' + i] = x;
  }
}

/**
 * Wait til next code execution cycle as fast as possible.
 */

function onnext(fn) {
  setTimeout(fn, 0);
}

})();

यह इस तरह इस्तेमाल किया जा सकता है:

window.onanyerror = function(entity){
  console.log('some error', entity);
};

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

window.onanyerror0
window.onanyerror1
...
window.onanyerror99

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

उम्मीद है की यह मदद करेगा।


1
जाहिरा तौर पर छवियां त्रुटि घटना को ट्रिगर करती हैं: stackoverflow.com/a/18152753/607033
inf3rno

6
// display error messages for a page, but never more than 3 errors
window.onerror = function(msg, url, line) {
if (onerror.num++ < onerror.max) {
alert("ERROR: " + msg + "\n" + url + ":" + line);
return true;
}
}
onerror.max = 3;
onerror.num = 0;

6

एक पहले से जुड़े onerror कॉलबैक को संरक्षित करना चाहिए

<script type="text/javascript">

(function() {
    var errorCallback = window.onerror;
    window.onerror = function () {
        // handle error condition
        errorCallback && errorCallback.apply(this, arguments);
    };
})();

</script>

3

यदि आप बिना किसी त्रुटि के दोनों को हैंडल करने के लिए एकीकृत तरीका चाहते हैं और अनचाहे वादे को अस्वीकार कर देते हैं, तो आपके पास अनकैप्ड लाइब्रेरी पर एक नज़र हो सकती है ।

संपादित करें

<script type="text/javascript" src=".../uncaught/lib/index.js"></script>

<script type="text/javascript">
    uncaught.start();
    uncaught.addListener(function (error) {
        console.log('Uncaught error or rejection: ', error.message);
    });
</script>

यह खिड़की सुनता है। Window.onerror के अलावा unhandledrejection


2
उपरोक्त उत्तर में लांस पोलार्ड ने कुछ त्रुटियों का उल्लेख किया है, जो सामान्य ऑनरोर संभालती नहीं है। क्या पुस्तकालय उन्हें संभालता है? यदि उनमें से कुछ, कृपया निर्दिष्ट करें कि कौन सा?
माइकल फ्रीजिम

@ MiFreidgeimSO-stopbeingevil बस स्रोत कोड की जाँच की - कोई दुर्भाग्य से यह नहीं करता है। अगर आप इस का समर्थन कर सकते हैं - तो मैं क्या कर सकता हूँ - मैं अपने
डाउनवोट को अपवोट

2

मैं Trackjs एक कोशिश देने की सिफारिश करेंगे ।

यह सेवा के रूप में लॉग इन करने में त्रुटि है।

यह स्थापित करने के लिए आश्चर्यजनक सरल है। बस प्रत्येक पृष्ठ पर एक <script> पंक्ति जोड़ें और वह यह है। इसका मतलब यह भी है कि यदि आप इसे पसंद नहीं करते हैं तो यह तय करना आश्चर्यजनक रूप से सरल होगा।

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


2
TrackJS के पास अब फ्री टियर नहीं है, हालांकि एक फ्री ट्रायल है।
pkaeding

यह ट्रैकिंग के लिए ठीक है और त्रुटियों के प्रति सचेत है लेकिन वास्तव में हैंडलिंग भाग को हल नहीं करता है। आदर्श रूप से मुझे लगता है कि पूछने वाला इन त्रुटियों को संभालने के लिए एक रास्ता ढूंढ रहा है ताकि बाकी कोड अभी भी चले।
wgp

क्या होगा यदि आप त्रुटि घटना को पकड़ते हैं और स्टैक ट्रेस और एप्लिकेशन स्थिति के साथ लकड़हारे को एक xhr कॉल जोड़ते हैं? ट्रैकज बेहतर कैसे है?
inf3rno

2
@ inf3rno यह एक स्टैक ट्रेस से अधिक है, जो सिर्फ त्रुटि की शुरुआत को ट्रैक करता है। TrackJS पूरे उपयोगकर्ता सत्र को ट्रैक करेगा ताकि आप देख सकें कि इसके लिए क्या नेतृत्व किया गया था। यहाँ एक उदाहरण के रूप में एक स्क्रीनशॉट trackjs.com/assets/images/screenshot.png
kane

1

आप onerror इवेंट को window.onerror पर एक फंक्शन असाइन करके सुनते हैं:

 window.onerror = function (msg, url, lineNo, columnNo, error) {
        var string = msg.toLowerCase();
        var substring = "script error";
        if (string.indexOf(substring) > -1){
            alert('Script Error: See Browser Console for Detail');
        } else {
            alert(msg, url, lineNo, columnNo, error);
        }   
      return false; 
  };
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.