renderErrorHandling.md

Notes

• This code handles any JS runtime error during rendering React components. Without this handling, once an error occurs, whole component tree is damaged and can't be used at all. With this handling, nothing will be rendered in production environment (error span in dev env.) + in production the error is logged to Sentry (if you are not using it just delete related code)
• This is basicaly a workaround for proposed feature in React core - described in Issue: facebook/react#2461
• Works for all variants of Component creation - React.createClass, extending React.Component and also stateless functional components.
• To get this work, just put this snippet into your entry js file. Then it will work in whole application.
• Also supporting React Hot Reload!
• If you find this useful, please retweet https://twitter.com/Aldredcz/status/744650159942995968 :)

Ideas

• specify custom error renderer (global / per component, e.g. by implementing method renderOnError() in a component)

Snippet code

import React from 'react';

const statelessComponentsMap = new Map(); // original -> monkeypatched stateless functional components cache
let errorPlaceholder = <noscript/>;

if (__DEV__) {
	errorPlaceholder = (
		<span
			style={{
				background: 'red',
				color: 'white'
			}}
		>
			Render error!
		</span>
	);
}

function logError(Component, error) {
	const errorMsg = `Error while rendering component. Check render() method of component '${Component.displayName || Component.name || '[unidentified]'}'.`;

	console.error(errorMsg, 'Error details:', error); // eslint-disable-line

	if (typeof Raven !== 'undefined' && typeof Raven.captureException === 'function') {
		Raven.captureException(new Error(errorMsg), {
			extra: {
				errorStack: error.stack
			}
		});
	}
}

function monkeypatchRender(prototype) {
	if (prototype && prototype.render && !prototype.render.__handlingErrors) {
		const originalRender = prototype.render;

		prototype.render = function monkeypatchedRender() {
			try {
				return originalRender.call(this);
			} catch (error) {
				logError(prototype.constructor, error);

				return errorPlaceholder;
			}
		};

		prototype.render.__handlingErrors = true; // flag render method so it's not wrapped multiple times
	}
}

const originalCreateElement = React.createElement;
React.createElement = (Component, ...rest) => {
	if (typeof Component === 'function') {

		if (Component.prototype && typeof Component.prototype.render === 'function') {
			monkeypatchRender(Component.prototype);
		}

		// stateless functional component
		if (!Component.prototype || !Component.prototype.render) {
			const originalStatelessComponent = Component;
			if (statelessComponentsMap.has(originalStatelessComponent)) { // load from cache
				Component = statelessComponentsMap.get(originalStatelessComponent);
			} else {
				Component = (...args) => {
					try {
						return originalStatelessComponent(...args);
					} catch (error) {
						logError(originalStatelessComponent, error);

						return errorPlaceholder;
					}
				};
				
				Object.assign(Component, originalStatelessComponent); // copy all properties like propTypes, defaultProps etc.
				statelessComponentsMap.set(originalStatelessComponent, Component); // save to cache, so we don't generate new monkeypatched functions every time.
			}
		}
	}

	return originalCreateElement.call(React, Component, ...rest);
};


// allowing hot reload
const originalForceUpdate = React.Component.prototype.forceUpdate;
React.Component.prototype.forceUpdate = function monkeypatchedForceUpdate() {
	monkeypatchRender(this);
	originalForceUpdate.call(this);
};

Have you seen skiano's react-safe-render? It takes care of wrapping more than just the call to render. Interesting idea to make development different from production here, I can see that coming in handy.

@vinnymac Didn't see it, I guess it works nicely for createClass approach,..

But doesn't handle other variants at all. Plus this gist also cover Hot Reload, so it may speed up development significantly (without error handling, error means F5 usually)

Works like a charm! Thanks 👍

@Aldredcz, have you encountered any issues with the stateless functional component portion of this? Everything else seems to work fine, but I'm running into issues with this particular component. No exception occurs, but the component does not render as expected.

const validate = ({ email, password }) => {
  const errors = {};
  if (!email || email.length === 0) errors.email = 'Please provide a valid email.';
  if (!password || password.length === 0) errors.password = 'Please provide a valid password.';
  return errors;
};

const LoginForm = reduxForm({
  form: 'login',
  fields: ['email', 'password'],
  validate,
})(({
  fields: { email, password },
  handleSubmit,
  submitting,
  invalid,
  error,
}) => (
  <form onSubmit={handleSubmit}>
    {error
      ? <div className="alert alert-danger" role="alert">{error}</div>
      : null}
    <FormField label="Email" placeholder="email@example.com" className="input-lg" {...email} />
    <FormField label="Password" placeholder="Password" type="password" className="input-lg" {...password} />
    <button className="btn btn-primary btn-lg btn-block" disabled={submitting || invalid}>
      <SubmitSpinner submitting={submitting} label={<span><i className="fa fa-sign-in" /> Log In</span>} />
    </button>
  </form>
));

@kelchm Functional stateless component works just fine for me. What is the result of your code? Nothing is rendered at all?

There are issues if a stateless component has a stateful child, as the monkeypatch replaces the entire stateless component every render, react doesn't recognize the old component as being equal to the new component, and all state on the child components is destroyed.

Additionally you're not assigning any properties that exist on the old stateless component to the new one, so you actually lose all your propTypes and defaultProps (although this is easily fixed at least - Object.assign(Component, originalStatelessComponent)

edit: Having a map of Component -> Wrapped component for stateless components works:

const originalCreateElement = React.createElement
const statelessMap = new Map()
React.createElement = (Component, ...rest) => {
  if (typeof Component === 'function') {

    if (typeof Component.prototype.render === 'function') {
      monkeypatchRender(Component.prototype)
    }

    // stateless functional component
    if (!Component.prototype.render) {
      const originalStatelessComponent = Component
      if (statelessMap.has(originalStatelessComponent)) {
        Component = statelessMap.get(originalStatelessComponent)
      } else {
        Component = (...args) => {
          try {
            return originalStatelessComponent(...args)
          } catch (error) {
            logError(originalStatelessComponent, error)

            return errorPlaceholder
          }
        }
        Object.assign(Component, originalStatelessComponent)
        statelessMap.set(originalStatelessComponent, Component)
      }
    }
  }

  return originalCreateElement.call(React, Component, ...rest)
}

https://gist.github.com/Psykar/d01f6e6e9575926768123ff7af82fd11

@Psykar thanks for the solution, I haven't used stateful components inside stateless ones to be honest.
I will integrate it into the gist :)

@Aldredcz Thank you so much!

Be careful, typeof Component.prototype.render: arrow functions do not have a prototype.

Here is my own (ES2015) implementation.

Thanks for you work :)

@julien-f Thanks, didn't know about arrow functions not having prototype. Also babel doesn't match this behavior with es2015 preset (https://babeljs.io/repl/#?babili=false&evaluate=true&lineWrap=false&presets=es2015&code=const%20testFn%20%3D%20()%20%3D%3E%20%7B%0A%7D%0A%0Aconsole.log(testFn.prototype)%0Aconsole.log(testFn.prototype.test))

Hmm not working for me. I still get uncaught errors.

@julien-f your solution works great for me but it blows up with HMR

Thanks for providing this. It solved exactly the problem I was dealing with and I was just getting ready to write something like this myself. So having a mostly working one is a godsend.

I did make one change in my version, I added a test for the existence of prototype on the component, as it is true, arrow functions don't have prototype if they are implemented directly in the language (not true for babel). Since I'm using node 6 I have access to native arrow functions, which don't have prototype at least on the server. I also changed one part to ignore components which extend a certain base class, but that is implementation specific.

@lassombra Thanks for your comment. I thought I've already solved the prototypeless case, but I only did it in one condition.

My bad. Fixed now :)

Any idea why this works only in development and doesn't work in production?
I already removed if (__DEV__) { condition obviously.

If someone still use this. The "allowing hot reload" part should be:

const originalForceUpdate = React.Component.prototype.forceUpdate;
React.Component.prototype.forceUpdate = function monkeypatchedForceUpdate(callback) {
	monkeypatchRender(this);
	originalForceUpdate.call(this, callback);
};

There was no callback argument. We had weird error in React-bootstrap (0.31.5) because of this - missing initial Modal animation but only for some ones. Also React-bootstrap (0.32.5 - latest on Bootstrap 3) not work at all with this ErrorHandler hack, have no clue why.