@cocalc/static

######################################################################### # This file is part of CoCalc: Copyright © 2020 Sagemath, Inc. # License: AGPLv3 s.t. "Commons Clause" – see LICENSE.md for details ######################################################################### # Catch and report webapp client errors to the SMC server. # This is based on bugsnag's MIT licensed lib: https://github.com/bugsnag/bugsnag-js # The basic idea is to wrap very early at a very low level of the event system, # such that all libraries loaded later are sitting on top of this. # Additionally, special care is taken to browser brands and their capabilities. # Finally, additional data about the webapp client is gathered and sent with the error report. # list of string-identifyers of errors, that were already reported. # this avoids excessive resubmission of errors already_reported = [] FUNCTION_REGEX = /function\s*([\w\-$]+)?\s*\(/i ignoreOnError = 0 shouldCatch = true # set this to true, to enable the webapp error reporter for development enable_for_testing = false if BACKEND? and BACKEND # never enable on the backend -- used by static react rendering. ENABLED = false else ENABLED = (not DEBUG) or enable_for_testing # this is the MAIN function of this module # it's exported publicly and also used in various spots where exceptions are already # caught and reported to the browser's console. reportException = (exception, name, severity, comment) -> if !exception or typeof exception == "string" return # setting those *Number defaults to `undefined` breaks somehow on its way # to the DB (it only wants NULL or an int). -1 is signaling that there is no info. sendError( name: name || exception.name message: exception.message || exception.description comment: comment ? '' stacktrace: stacktraceFromException(exception) || generateStacktrace() file: exception.fileName || exception.sourceURL path: window.location.href lineNumber: exception.lineNumber || exception.line || -1 columnNumber: exception.columnNumber || -1 severity: severity || "default" ) WHITELIST = ['componentWillMount has been renamed', 'componentWillReceiveProps has been renamed', 'a whole package of antd'] isWhitelisted = (opts) -> s = JSON.stringify(opts) for x in WHITELIST if s.indexOf(x) != -1 return true return false # this is the final step sending the error report. # it gathers additional information about the webapp client. currentlySendingError = false; sendError = (opts) -> #console.log("sendError", currentlySendingError, opts); if currentlySendingError # errors can be crazy and easily DOS the user's connection. Since this table is # just something we manually check sometimes, not sending too many errors is # best. We send at most one at a time. See https://github.com/sagemathinc/cocalc/issues/5771 return currentlySendingError = true require.ensure [], => try #console.log 'sendError', opts if isWhitelisted(opts) #console.log 'sendError: whitelisted' # Ignore this antd message in browser. return misc = require('@cocalc/util/misc') opts = misc.defaults opts, name : misc.required message : misc.required comment : '' stacktrace : '' file : '' path : '' lineNumber : -1 columnNumber : -1 severity : 'default' fingerprint = misc.uuidsha1([opts.name, opts.message, opts.comment].join('::')) if fingerprint in already_reported and not DEBUG return already_reported.push(fingerprint) # attaching some additional info feature = require('@cocalc/frontend/feature') opts.user_agent = navigator?.userAgent opts.browser = feature.get_browser() opts.mobile = feature.IS_MOBILE opts.smc_version = SMC_VERSION opts.build_date = BUILD_DATE opts.smc_git_rev = COCALC_GIT_REVISION opts.uptime = misc.get_uptime() opts.start_time = misc.get_start_time_ts() if DEBUG then console.info('error reporter sending:', opts) try # During initial load in some situations evidently webapp_client # is not yet initialized, and webapp_client is undefined. (Maybe # a typescript rewrite of everything relevant will help...). In # any case, for now we # https://github.com/sagemathinc/cocalc/issues/4769 # As an added bonus, by try/catching and retrying once at least, # we are more likely to get the error report in case of a temporary # network or other glitch.... console.log 'sendError: import webapp_client' {webapp_client} = require('@cocalc/frontend/webapp-client') # can possibly be undefined # console.log 'sendError: sending error' await webapp_client.tracking_client.webapp_error(opts) # might fail. # console.log 'sendError: got response' catch err console.info("failed to report error; trying again in 30 seconds", err, opts) {delay} = require('awaiting'); await delay(30000) try {webapp_client} = require('@cocalc/frontend/webapp-client') await webapp_client.tracking_client.webapp_error(opts) catch err console.info("failed to report error", err) finally currentlySendingError = false # neat trick to get a stacktrace when there is none generateStacktrace = () -> generated = stacktrace = null MAX_FAKE_STACK_SIZE = 10 ANONYMOUS_FUNCTION_PLACEHOLDER = "[anonymous]" try throw new Error("") catch exception generated = "<generated>\n" stacktrace = stacktraceFromException(exception) if not stacktrace generated = "<generated-ie>\n" functionStack = [] try curr = arguments.callee.caller.caller while curr && functionStack.length < MAX_FAKE_STACK_SIZE if FUNCTION_REGEX.test(curr.toString()) fn = RegExp.$1 ? ANONYMOUS_FUNCTION_PLACEHOLDER else fn = ANONYMOUS_FUNCTION_PLACEHOLDER functionStack.push(fn) curr = curr.caller catch e #console.error(e) stacktrace = functionStack.join("\n") return generated + stacktrace stacktraceFromException = (exception) -> return exception.stack || exception.backtrace || exception.stacktrace # Disable catching on IE < 10 as it destroys stack-traces from generateStackTrace() # OF COURSE, COCALC doesn't support any version of IE at all, so ... if (not window.atob) shouldCatch = false # Disable catching on browsers that support HTML5 ErrorEvents properly. # This lets debug on unhandled exceptions work. # TODO: enabling the block below distorts (at least) Chrome error messages. # Maybe Chrome's window.onerror doesn't work as assumed? # else if window.ErrorEvent # try # if new window.ErrorEvent("test").colno == 0 # shouldCatch = false # catch e # # No action needed # flag to ignore "onerror" when already wrapped in the event handler ignoreNextOnError = () -> ignoreOnError += 1 window.setTimeout((-> ignoreOnError -= 1)) # this is the "brain" of all this wrap = (_super) -> try if typeof _super != "function" return _super if !_super._wrapper _super._wrapper = () -> if shouldCatch try return _super.apply(this, arguments) catch e reportException(e, null, "error") ignoreNextOnError() throw e else return _super.apply(this, arguments) _super._wrapper._wrapper = _super._wrapper return _super._wrapper catch e return _super # replaces an attribute of an object by a function that has it as an argument polyFill = (obj, name, makeReplacement) -> original = obj[name] replacement = makeReplacement(original) obj[name] = replacement # wrap all prototype objects that have event handlers # first one is for chrome, the first three for FF, the rest for IE, Safari, etc. if ENABLED "EventTarget Window Node ApplicationCache AudioTrackList ChannelMergerNode CryptoOperation EventSource FileReader HTMLUnknownElement IDBDatabase IDBRequest IDBTransaction KeyOperation MediaController MessagePort ModalWindow Notification SVGElementInstance Screen TextTrack TextTrackCue TextTrackList WebSocket WebSocketWorker Worker XMLHttpRequest XMLHttpRequestEventTarget XMLHttpRequestUpload".replace(/\w+/g, (global) -> prototype = window[global]?.prototype if prototype?.hasOwnProperty?("addEventListener") polyFill(prototype, "addEventListener", (_super) -> return (e, f, capture, secure) -> try if f and f.handleEvent f.handleEvent = wrap(f.handleEvent) catch err #console.log(err) return _super.call(this, e, wrap(f), capture, secure) ) polyFill(prototype, "removeEventListener", (_super) -> return (e, f, capture, secure) -> _super.call(this, e, f, capture, secure) return _super.call(this, e, wrap(f), capture, secure) ) ) if ENABLED polyFill(window, "onerror", (_super) -> return (message, url, lineNo, charNo, exception) -> # IE 6+ support. if !charNo and window.event charNo = window.event.errorCharacter #if DEBUG # console.log("intercepted window.onerror", message, url, lineNo, charNo, exception) if ignoreOnError == 0 name = exception?.name or "window.onerror" stacktrace = (exception and stacktraceFromException(exception)) or generateStacktrace() sendError( name : name message : message file : url path : window.location.href lineNumber : lineNo columnNumber: charNo stacktrace : stacktrace severity : "error" ) # Fire the existing `window.onerror` handler, if one exists if _super _super(message, url, lineNo, charNo, exception) ) # timing functions hijackTimeFunc = (_super) -> return (f, t) -> if typeof f == "function" f = wrap(f) args = Array.prototype.slice.call(arguments, 2) return _super((-> f.apply(this, args)), t) else return _super(f, t) if ENABLED polyFill(window, "setTimeout", hijackTimeFunc) polyFill(window, "setInterval", hijackTimeFunc) if ENABLED and window.requestAnimationFrame polyFill(window, "requestAnimationFrame", (_super) -> (callback) -> return _super(wrap(callback)) ) if ENABLED and window.setImmediate polyFill(window, "setImmediate", (_super) -> return () -> args = Array.prototype.slice.call(arguments) args[0] = wrap(args[0]) return _super.apply(this, args) ) # console terminal sendLogLine = (severity, args) -> require.ensure [], => misc = require('@cocalc/util/misc') if typeof(args) == 'object' message = misc.trunc_middle(misc.to_json(args), 1000) else message = Array.prototype.slice.call(args).join(", ") sendError( name : 'Console Output' message : message file : '' path : window.location.href lineNumber : -1 columnNumber: -1 stacktrace : generateStacktrace() severity : severity ) wrapFunction = (object, property, newFunction) -> oldFunction = object[property] object[property] = () -> newFunction.apply(this, arguments) if typeof oldFunction == "function" oldFunction.apply(this, arguments) if ENABLED and window.console? wrapFunction(console, "warn", (-> sendLogLine("warn", arguments))) wrapFunction(console, "error", (-> sendLogLine("error", arguments))) if ENABLED window.addEventListener "unhandledrejection",(e) -> require.ensure [], => # just to make sure there is a message reason = e.reason ? '<no reason>' if typeof(reason) == 'object' misc = require('@cocalc/util/misc') reason = "#{reason.stack ? reason.message ? misc.trunc_middle(misc.to_json(reason), 1000)}" e.message = "unhandledrejection: #{reason}" reportException(e, "unhandledrejection") # public API exports.reportException = reportException if DEBUG window.cc ?= {} window.cc.webapp_error_reporter = shouldCatch : -> shouldCatch ignoreOnError : -> ignoreOnError already_reported : -> already_reported stacktraceFromException : stacktraceFromException generateStacktrace : generateStacktrace sendLogLine : sendLogLine reportException : reportException is_enabled : -> ENABLED