258 lines
7.0 KiB
JavaScript
258 lines
7.0 KiB
JavaScript
/**
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*
|
|
* @flow strict
|
|
* @format
|
|
*/
|
|
|
|
import type {Stack} from './LogBoxSymbolication';
|
|
import type {
|
|
Category,
|
|
CodeFrame,
|
|
ComponentStack,
|
|
ComponentStackType,
|
|
Message,
|
|
} from './parseLogBoxLog';
|
|
|
|
import * as LogBoxSymbolication from './LogBoxSymbolication';
|
|
|
|
type SymbolicationStatus = 'NONE' | 'PENDING' | 'COMPLETE' | 'FAILED';
|
|
|
|
export type LogLevel = 'warn' | 'error' | 'fatal' | 'syntax';
|
|
|
|
// TODO: once component stacks are fully supported, we can refactor
|
|
// ComponentStack to just be Stack and remove these conversions fns.
|
|
function convertComponentStateToStack(componentStack: ComponentStack): Stack {
|
|
return componentStack.map(frame => ({
|
|
column: frame?.location?.column,
|
|
file: frame.fileName,
|
|
lineNumber: frame?.location?.row,
|
|
methodName: frame.content,
|
|
collapse: false,
|
|
}));
|
|
}
|
|
|
|
function convertStackToComponentStack(stack: Stack): ComponentStack {
|
|
const componentStack = [];
|
|
for (let i = 0; i < stack.length; i++) {
|
|
const frame = stack[i];
|
|
// NOTE: Skip stack frames missing location.
|
|
if (frame.lineNumber != null && frame.column != null) {
|
|
componentStack.push({
|
|
fileName: frame?.file || '',
|
|
location: {
|
|
row: frame.lineNumber,
|
|
column: frame.column,
|
|
},
|
|
content: frame.methodName,
|
|
collapse: false,
|
|
});
|
|
}
|
|
}
|
|
return componentStack;
|
|
}
|
|
|
|
export type LogBoxLogData = $ReadOnly<{
|
|
level: LogLevel,
|
|
type?: ?string,
|
|
message: Message,
|
|
stack: Stack,
|
|
category: string,
|
|
componentStackType?: ComponentStackType,
|
|
componentStack: ComponentStack,
|
|
codeFrame?: ?CodeFrame,
|
|
isComponentError: boolean,
|
|
extraData?: mixed,
|
|
onNotificationPress?: ?() => void,
|
|
}>;
|
|
|
|
class LogBoxLog {
|
|
message: Message;
|
|
type: ?string;
|
|
category: Category;
|
|
componentStack: ComponentStack;
|
|
componentStackType: ComponentStackType;
|
|
stack: Stack;
|
|
count: number;
|
|
level: LogLevel;
|
|
codeFrame: ?CodeFrame;
|
|
isComponentError: boolean;
|
|
extraData: mixed | void;
|
|
symbolicated:
|
|
| $ReadOnly<{|error: null, stack: null, status: 'NONE'|}>
|
|
| $ReadOnly<{|error: null, stack: null, status: 'PENDING'|}>
|
|
| $ReadOnly<{|error: null, stack: Stack, status: 'COMPLETE'|}>
|
|
| $ReadOnly<{|error: Error, stack: null, status: 'FAILED'|}> = {
|
|
error: null,
|
|
stack: null,
|
|
status: 'NONE',
|
|
};
|
|
symbolicatedComponentStack:
|
|
| $ReadOnly<{|error: null, componentStack: null, status: 'NONE'|}>
|
|
| $ReadOnly<{|error: null, componentStack: null, status: 'PENDING'|}>
|
|
| $ReadOnly<{|
|
|
error: null,
|
|
componentStack: ComponentStack,
|
|
status: 'COMPLETE',
|
|
|}>
|
|
| $ReadOnly<{|error: Error, componentStack: null, status: 'FAILED'|}> = {
|
|
error: null,
|
|
componentStack: null,
|
|
status: 'NONE',
|
|
};
|
|
onNotificationPress: ?() => void;
|
|
|
|
constructor(data: LogBoxLogData) {
|
|
this.level = data.level;
|
|
this.type = data.type;
|
|
this.message = data.message;
|
|
this.stack = data.stack;
|
|
this.category = data.category;
|
|
this.componentStack = data.componentStack;
|
|
this.componentStackType = data.componentStackType || 'legacy';
|
|
this.codeFrame = data.codeFrame;
|
|
this.isComponentError = data.isComponentError;
|
|
this.extraData = data.extraData;
|
|
this.count = 1;
|
|
this.onNotificationPress = data.onNotificationPress;
|
|
}
|
|
|
|
incrementCount(): void {
|
|
this.count += 1;
|
|
}
|
|
|
|
getAvailableStack(): Stack {
|
|
return this.symbolicated.status === 'COMPLETE'
|
|
? this.symbolicated.stack
|
|
: this.stack;
|
|
}
|
|
|
|
getAvailableComponentStack(): ComponentStack {
|
|
if (this.componentStackType === 'legacy') {
|
|
return this.componentStack;
|
|
}
|
|
return this.symbolicatedComponentStack.status === 'COMPLETE'
|
|
? this.symbolicatedComponentStack.componentStack
|
|
: this.componentStack;
|
|
}
|
|
|
|
retrySymbolicate(callback?: (status: SymbolicationStatus) => void): void {
|
|
if (this.symbolicated.status !== 'COMPLETE') {
|
|
LogBoxSymbolication.deleteStack(this.stack);
|
|
this.handleSymbolicate(callback);
|
|
}
|
|
}
|
|
|
|
symbolicate(callback?: (status: SymbolicationStatus) => void): void {
|
|
if (this.symbolicated.status === 'NONE') {
|
|
this.handleSymbolicate(callback);
|
|
}
|
|
}
|
|
|
|
handleSymbolicate(callback?: (status: SymbolicationStatus) => void): void {
|
|
if (this.symbolicated.status !== 'PENDING') {
|
|
this.updateStatus(null, null, null, callback);
|
|
LogBoxSymbolication.symbolicate(this.stack, this.extraData).then(
|
|
data => {
|
|
this.updateStatus(null, data?.stack, data?.codeFrame, callback);
|
|
},
|
|
error => {
|
|
this.updateStatus(error, null, null, callback);
|
|
},
|
|
);
|
|
if (this.componentStack != null && this.componentStackType === 'stack') {
|
|
this.updateComponentStackStatus(null, null, null, callback);
|
|
const componentStackFrames = convertComponentStateToStack(
|
|
this.componentStack,
|
|
);
|
|
LogBoxSymbolication.symbolicate(componentStackFrames, []).then(
|
|
data => {
|
|
this.updateComponentStackStatus(
|
|
null,
|
|
convertStackToComponentStack(data.stack),
|
|
null,
|
|
callback,
|
|
);
|
|
},
|
|
error => {
|
|
this.updateComponentStackStatus(error, null, null, callback);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
updateStatus(
|
|
error: ?Error,
|
|
stack: ?Stack,
|
|
codeFrame: ?CodeFrame,
|
|
callback?: (status: SymbolicationStatus) => void,
|
|
): void {
|
|
const lastStatus = this.symbolicated.status;
|
|
if (error != null) {
|
|
this.symbolicated = {
|
|
error,
|
|
stack: null,
|
|
status: 'FAILED',
|
|
};
|
|
} else if (stack != null) {
|
|
if (codeFrame) {
|
|
this.codeFrame = codeFrame;
|
|
}
|
|
|
|
this.symbolicated = {
|
|
error: null,
|
|
stack,
|
|
status: 'COMPLETE',
|
|
};
|
|
} else {
|
|
this.symbolicated = {
|
|
error: null,
|
|
stack: null,
|
|
status: 'PENDING',
|
|
};
|
|
}
|
|
|
|
if (callback && lastStatus !== this.symbolicated.status) {
|
|
callback(this.symbolicated.status);
|
|
}
|
|
}
|
|
|
|
updateComponentStackStatus(
|
|
error: ?Error,
|
|
componentStack: ?ComponentStack,
|
|
codeFrame: ?CodeFrame,
|
|
callback?: (status: SymbolicationStatus) => void,
|
|
): void {
|
|
const lastStatus = this.symbolicatedComponentStack.status;
|
|
if (error != null) {
|
|
this.symbolicatedComponentStack = {
|
|
error,
|
|
componentStack: null,
|
|
status: 'FAILED',
|
|
};
|
|
} else if (componentStack != null) {
|
|
this.symbolicatedComponentStack = {
|
|
error: null,
|
|
componentStack,
|
|
status: 'COMPLETE',
|
|
};
|
|
} else {
|
|
this.symbolicatedComponentStack = {
|
|
error: null,
|
|
componentStack: null,
|
|
status: 'PENDING',
|
|
};
|
|
}
|
|
|
|
if (callback && lastStatus !== this.symbolicatedComponentStack.status) {
|
|
callback(this.symbolicatedComponentStack.status);
|
|
}
|
|
}
|
|
}
|
|
|
|
export default LogBoxLog;
|