feat(observability): allow defining custom uncaught exception handler

flavors/swagger-ui-react/README.md

@@ -200,6 +200,15 @@ Passes initial values to the Swagger UI state.
 
 ⚠️ This prop is currently only applied once, on mount. Changes to this prop's value will not be propagated to the underlying Swagger UI instance. A future version of this module will remove this limitation, and the change will not be considered a breaking change.
 
+
+#### `uncaughtExceptionHandler`: PropTypes.func
+
+Allows to define a custom uncaught exception handler. The default is `null`, which means that the default handler will be used. 
+The default handler will log the error to the console.
+
+⚠️ This prop is currently only applied once, on mount. Changes to this prop's value will not be propagated to the underlying Swagger UI instance. A future version of this module will remove this limitation, and the change will not be considered a breaking change.
+
+
 ## Limitations
 
 * Not all configuration bindings are available.

flavors/swagger-ui-react/index.jsx

@@ -46,6 +46,7 @@ const SwaggerUI = ({
   oauth2RedirectUrl = config.defaults.oauth2RedirectUrl,
   onComplete = null,
   initialState = config.defaults.initialState,
+  uncaughtExceptionHandler = config.defaults.uncaughtExceptionHandler,
 }) => {
   const [system, setSystem] = useState(null)
   const SwaggerUIComponent = system?.getComponent("App", "root")
@@ -85,6 +86,7 @@ const SwaggerUI = ({
       persistAuthorization,
       withCredentials,
       initialState,
+      uncaughtExceptionHandler,
       ...(typeof oauth2RedirectUrl === "string"
         ? { oauth2RedirectUrl: oauth2RedirectUrl }
         : {}),
@@ -168,6 +170,7 @@ SwaggerUI.propTypes = {
   withCredentials: PropTypes.bool,
   oauth2RedirectUrl: PropTypes.string,
   initialState: PropTypes.object,
+  uncaughtExceptionHandler: PropTypes.func,
 }
 SwaggerUI.System = SwaggerUIConstructor.System
 SwaggerUI.presets = SwaggerUIConstructor.presets

src/core/config/defaults.js

@@ -94,6 +94,8 @@ const defaultOptions = Object.freeze({
     "audio/",
     "video/",
   ],
+
+  uncaughtExceptionHandler: null,
 })
 
 export default defaultOptions

src/core/config/type-cast/mappings.js

@@ -133,6 +133,7 @@ const mappings = {
     typeCaster: booleanTypeCaster,
     defaultValue: defaultOptions.withCredentials,
   },
+  uncaughtExceptionHandler: { typeCaster: nullableFunctionTypeCaster },
 }
 
 export default mappings

src/core/system.js

@@ -124,7 +124,7 @@ export default class Store {
   }
 
   rebuildReducer() {
-    this.store.replaceReducer(buildReducer(this.system.statePlugins))
+    this.store.replaceReducer(buildReducer(this.system.statePlugins, this.getSystem))
   }
 
   /**
@@ -176,7 +176,7 @@ export default class Store {
                 if(!isFn(newAction)) {
                   throw new TypeError("wrapActions needs to return a function that returns a new function (ie the wrapped action)")
                 }
-                return wrapWithTryCatch(newAction)
+                return wrapWithTryCatch(newAction, this.getSystem)
               }, action || Function.prototype)
             })
           }
@@ -256,11 +256,11 @@ export default class Store {
 
       return objMap(obj, (fn) => {
         return (...args) => {
-          let res = wrapWithTryCatch(fn).apply(null, [getNestedState(), ...args])
+          let res = wrapWithTryCatch(fn, this.getSystem).apply(null, [getNestedState(), ...args])
 
           //  If a selector returns a function, give it the system - for advanced usage
           if(typeof(res) === "function")
-            res = wrapWithTryCatch(res)(getSystem())
+            res = wrapWithTryCatch(res, this.getSystem)(getSystem())
 
           return res
         }
@@ -333,7 +333,7 @@ function callAfterLoad(plugins, system, { hasLoaded } = {}) {
   if(isObject(plugins) && !isArray(plugins)) {
     if(typeof plugins.afterLoad === "function") {
       calledSomething = true
-      wrapWithTryCatch(plugins.afterLoad).call(this, system)
+      wrapWithTryCatch(plugins.afterLoad, system.getSystem).call(this, system)
     }
   }
 
@@ -436,16 +436,16 @@ function systemExtend(dest={}, src={}) {
   return deepExtend(dest, src)
 }
 
-function buildReducer(states) {
+function buildReducer(states, getSystem) {
   let reducerObj = objMap(states, (val) => {
     return val.reducers
   })
-  return allReducers(reducerObj)
+  return allReducers(reducerObj, getSystem)
 }
 
-function allReducers(reducerSystem) {
+function allReducers(reducerSystem, getSystem) {
   let reducers = Object.keys(reducerSystem).reduce((obj, key) => {
-    obj[key] = makeReducer(reducerSystem[key])
+    obj[key] = makeReducer(reducerSystem[key], getSystem)
     return obj
   },{})
 
@@ -456,14 +456,14 @@ function allReducers(reducerSystem) {
   return combineReducers(reducers)
 }
 
-function makeReducer(reducerObj) {
+function makeReducer(reducerObj, getSystem) {
   return (state = new Map(), action) => {
     if(!reducerObj)
       return state
 
     let redFn = (reducerObj[action.type])
     if(redFn) {
-      const res = wrapWithTryCatch(redFn)(state, action)
+      const res = wrapWithTryCatch(redFn, getSystem)(state, action)
       // If the try/catch wrapper kicks in, we'll get null back...
       // in that case, we want to avoid making any changes to state
       return res === null ? state : res
@@ -472,7 +472,7 @@ function makeReducer(reducerObj) {
   }
 }
 
-function wrapWithTryCatch(fn, {
+function wrapWithTryCatch(fn, getSystem, {
   logErrors = true
 } = {}) {
   if(typeof fn !== "function") {
@@ -482,9 +482,14 @@ function wrapWithTryCatch(fn, {
   return function(...args) {
     try {
       return fn.call(this, ...args)
-    } catch(e) {
+    } catch(error) {
       if(logErrors) {
-        console.error(e)
+        const { uncaughtExceptionHandler} = getSystem().getConfigs()
+        if (typeof uncaughtExceptionHandler === "function") {
+          uncaughtExceptionHandler(error)
+        } else {
+          console.error(error)
+        }
       }
       return null
     }