add setting's option to log errors to files

index.js

@@ -78,66 +78,69 @@ const {
 
 const io = require('./utility/io')
 
-const should_log = true
+function setLogMethod(should_log_to_file = true) {
-if (should_log) {
+    let timer_id
-    setInterval(async () => {
+    if (should_log_to_file) {
-        await io.deleteFileIfLargerThan('log.txt', 200)
+        console.log = (data, ...optional_param) => {
-    }, 2 * 60 * 1000)
+            try {
-    window.addEventListener('error', (event) => {
+                _log(data, ...optional_param)
-        const [a, b, c, d, e] = [1, 2, 3, 4, 5]
-        console.log(`message: ${a}`)
-        console.log(`source: ${b}`)
-        console.log(`lineno: ${c}`)
-        console.log(`colno: ${d}`)
-        console.log(`error: ${e}`)
-    })
 
-    console.log = (data, ...optional_param) => {
+                // const error = new Error({ data, ...optional_param });
-        try {
+                const formattedOutput = logger.formateLog(
-            _log(data, ...optional_param)
+                    data,
-
+                    ...optional_param
-            // const error = new Error({ data, ...optional_param });
+                )
-            const formattedOutput = logger.formateLog(data, ...optional_param)
+                io.IOLog.saveLogToFile({ log: formattedOutput }, 'log.txt')
-            io.IOLog.saveLogToFile({ log: formattedOutput }, 'log.txt')
+            } catch (e) {
-        } catch (e) {
+                _warn('error while logging: ')
-            _warn('error while logging: ')
+                _warn(e)
-            _warn(e)
+            }
         }
-    }
 
-    console.warn = (data, ...optional_param) => {
+        console.warn = (data, ...optional_param) => {
-        try {
+            try {
-            _warn(data, ...optional_param)
+                _warn(data, ...optional_param)
-            const error = new Error()
+                const error = new Error()
-            const stackTrace = error.stack
+                const stackTrace = error.stack
-            const formattedOutput = logger.formateLog(data, ...optional_param)
+                const formattedOutput = logger.formateLog(
-            io.IOLog.saveLogToFile(
+                    data,
-                { warning: formattedOutput, stackTrace },
+                    ...optional_param
-                'log.txt'
+                )
-            )
+                io.IOLog.saveLogToFile(
-        } catch (e) {
+                    { warning: formattedOutput, stackTrace },
-            _warn('error while logging: ')
+                    'log.txt'
-            _warn(e)
+                )
+            } catch (e) {
+                _warn('error while logging: ')
+                _warn(e)
+            }
         }
-    }
 
-    console.error = (data, ...optional_param) => {
+        console.error = (data, ...optional_param) => {
-        try {
+            try {
-            _error(data, ...optional_param)
+                _error(data, ...optional_param)
-            const error = new Error()
+                const error = new Error()
-            const stackTrace = error.stack
+                const stackTrace = error.stack
-            const formattedOutput = logger.formateLog(data, ...optional_param)
+                const formattedOutput = logger.formateLog(
-            io.IOLog.saveLogToFile(
+                    data,
-                { error: formattedOutput, stackTrace },
+                    ...optional_param
-                'log.txt'
+                )
-            )
+                io.IOLog.saveLogToFile(
-        } catch (e) {
+                    { error: formattedOutput, stackTrace },
-            _error('error while logging: ')
+                    'log.txt'
-            _error(e)
+                )
+            } catch (e) {
+                _error('error while logging: ')
+                _error(e)
+            }
         }
+    } else {
+        console.log = _log
+        console.warn = _warn
+        console.error = _error
     }
 }
-
+setLogMethod(settings_tab_ts.store.data.should_log_to_file)
 // const ultimate_sd_upscaler_script_test = require('./ultimate_sd_upscaler/dist/main')
 
 // const {

typescripts/settings/settings.tsx

@@ -3,9 +3,11 @@ import ReactDOM from 'react-dom/client'
 import { observer } from 'mobx-react'
 import { AStore } from '../main/astore'
 
-import { SpMenu } from '../util/elements'
+import { SpCheckBox, SpMenu } from '../util/elements'
 import Locale from '../locale/locale'
 import globalStore from '../globalstore'
+import { io } from '../util/oldSystem'
+import { reaction } from 'mobx'
 // import { Jimp } from '../util/oldSystem'
 declare const Jimp: any // make sure you import jimp before importing settings.tsx
 
@@ -33,8 +35,62 @@ const interpolationMethods: InterpolationMethod = {
 
 export const store = new AStore({
     scale_interpolation_method: interpolationMethods.bilinear,
+    should_log_to_file: false,
+    delete_log_file_timer_id: null,
 })
+function onShouldLogToFileChange(event: any) {
+    try {
+        const should_log_to_file: boolean = event.target.checked
+        store.data.should_log_to_file = should_log_to_file
+        if (should_log_to_file && !store.data.delete_log_file_timer_id) {
+            store.data.delete_log_file_timer_id = setDeleteLogTimer()
+        } else {
+            //don't log and clear delete file timer
+            try {
+                store.data.delete_log_file_timer_id = clearInterval(
+                    store.data.delete_log_file_timer_id
+                )
+            } catch (e) {
+                console.warn(e)
+            }
+        }
 
+        //@ts-ignore
+        setLogMethod(should_log_to_file)
+    } catch (e) {
+        console.warn(e)
+    }
+}
+
+function setDeleteLogTimer() {
+    const timer_id = setInterval(async () => {
+        await io.deleteFileIfLargerThan('log.txt', 200)
+    }, 2 * 60 * 1000)
+    console.log('setDeleteLogTimer() timer_id :', timer_id)
+    return timer_id
+}
+// reaction(
+//     () => {
+//         return store.data.should_log_to_file
+//     },
+//     (should_log_to_file) => {
+//         if (should_log_to_file && !store.data.delete_log_file_timer_id) {
+//             store.data.delete_log_file_timer_id = setDeleteLogTimer()
+//         } else {
+//             //don't log and clear delete file timer
+//             try {
+//                 store.data.delete_log_file_timer_id = clearInterval(
+//                     store.data.delete_log_file_timer_id
+//                 )
+//             } catch (e) {
+//                 console.warn(e)
+//             }
+//         }
+
+//         //@ts-ignore
+//         setLogMethod(should_log_to_file)
+//     }
+// )
 const Settings = observer(() => {
     return (
         <div style={{ width: '100%' }}>
@@ -67,10 +123,22 @@ const Settings = observer(() => {
                 label_item="select language"
                 selected_index={['en_US', 'zh_CN'].indexOf(globalStore.Locale)}
                 onChange={(id: any, value: any) => {
-                    globalStore.Locale = value.item;
+                    globalStore.Locale = value.item
-                    localStorage.setItem('last_selected_locale', value);
+                    localStorage.setItem('last_selected_locale', value)
                 }}
             ></SpMenu>
+            <SpCheckBox
+                style={{
+                    marginRight: '10px',
+                }}
+                onChange={onShouldLogToFileChange}
+                checked={store.data.should_log_to_file}
+            >
+                {
+                    //@ts-ignore
+                    Locale('Log Errors To File')
+                }
+            </SpCheckBox>
         </div>
     )
 })