Add fancy parsing of exceptions in background jobs

Author: icewind1991

js/Components/BackgroundException.js

@@ -0,0 +1,59 @@
+import {Component} from 'react';
+import {TraceLine} from './TraceLine.js';
+
+import style from './Exception.less';
+
+export class BackgroundException extends Component {
+	state = {
+		expanded: false
+	};
+
+	clickHandler = () => {
+		this.setState({
+			expanded: !this.state.expanded
+		});
+	};
+
+	render () {
+		var traceElements;
+		let jobArguments;
+		if (this.state.expanded) {
+			traceElements = this.props.Trace.map((trace, i) => {
+				return (
+					<TraceLine key={i} {...trace}/>
+				);
+			});
+			if (this.props.jobArguments.substr) {
+				jobArguments = this.props.jobArguments;
+			} else {
+				jobArguments = '{\n' + Object.keys(this.props.jobArguments).map(key => {
+						return `\t${key}: ${JSON.stringify(this.props.jobArguments[key])}`;
+					}).join(',\n') + '\n}';
+			}
+			traceElements = (
+				<span>
+					<pre>
+						<span
+							className={style.exception}>{this.props.jobClass}</span> {jobArguments}
+					</pre>
+					<ol className={style.trace} start="0">
+						{traceElements}
+					</ol>
+				</span>
+			)
+		} else {
+			traceElements = [];
+		}
+		return (
+			<span
+				className={style.exceptionRow + ' ' + (this.state.expanded ? style.expanded:style.retracted)}
+				onClick={this.clickHandler}>
+				Error while running background job&nbsp;
+				<span
+					className={style.exception}>({this.props.Exception})</span>:
+				<span className={style.messsage}> {this.props.Message}</span>
+				{traceElements}
+			</span>
+		);
+	}
+}

js/Components/LogEntry.js

@@ -1,7 +1,8 @@
 import {Component} from 'react';
 
-import {ExceptionParser} from '../ExceptionParser.js';
-import {Exception} from './Exception.js';
+import {ExceptionParser} from '../ExceptionParser';
+import {Exception} from './Exception';
+import {BackgroundException} from './BackgroundException';
 
 export class LogEntry extends Component {
 	constructor () {
@@ -10,7 +11,9 @@ export class LogEntry extends Component {
 	}
 
 	render () {
-		if (this.isException()) {
+		if (this.isBackgroundJobException()) {
+			return this.renderBackgroundException();
+		}else if (this.isException()) {
 			return this.renderException();
 		} else {
 			return this.renderBasic();
@@ -30,6 +33,17 @@ export class LogEntry extends Component {
 		);
 	}
 
+	renderBackgroundException () {
+		var exceptionData = this.exceptionParser.parse(this.props.message);
+		return (
+			<BackgroundException {...exceptionData}/>
+		);
+	}
+
+	isBackgroundJobException () {
+		return this.exceptionParser.isBackgroundJobException(this.props.message);
+	}
+
 	isException () {
 		return this.exceptionParser.isException(this.props.message);
 	}

js/ExceptionParser.js

@@ -1,15 +1,50 @@
+import unserialize from './unserialize';
+
+window.unserialize = unserialize;
+
 export class ExceptionParser {
 	isException (logMessage) {
+		return this.isRegularException(logMessage) || this.isBackgroundJobException(logMessage);
+	}
+
+	isRegularException (logMessage) {
 		return logMessage.substr(0, 12) === 'Exception: {';
 	}
 
+	isBackgroundJobException (logMessage) {
+		return logMessage.substr(0, 34) === 'Error while running background job' && logMessage.indexOf('{"Exception":') !== -1;
+	}
+
 	parse (logMessage) {
-		let data = JSON.parse(logMessage.substr(10));
+		let data;
+		if (this.isRegularException(logMessage)) {
+			data = JSON.parse(logMessage.substr(10));
+		} else {
+			data = JSON.parse(logMessage.substr(logMessage.indexOf('{"Exception":')));
+			const messageHead = logMessage.substr(0, logMessage.indexOf('{"Exception":'));
+			const jobDataString = messageHead.split('(', 2)[1];
+			const jobDataParts = jobDataString.split(',', 2).map(part=>part.trim());
+			data.jobClass = jobDataParts[0].split(':', 2)[1].trim();
+			data.jobArguments = jobDataParts[1].substr(10).trim();
+			window.s = jobDataParts[1].substr(10).trim();
+			if (data.jobClass === 'OC\\Command\\CommandJob') {
+				try {
+					[data.jobClass, data.jobArguments] = this.parseCommandJob(data.jobArguments);
+				} catch (e) {
+					
+				}
+			}
+		}
 		let traceLines = data.Trace.split('\n');
 		data.Trace = traceLines.map(this.parseTraceLine);
 		return data;
 	}
 
+	parseCommandJob (data) {
+		const parsed = unserialize(data);
+		return [parsed['class'], parsed.properties];
+	}
+
 	parseTraceLine (line) {
 		let parts = line.split(' ');
 		let number = parts.shift();