visang-tracker 1.0.0

package/.prettierignore

@@ -0,0 +1 @@
+*.css

package/.prettierrc

@@ -0,0 +1,10 @@
+{
+    "singleQuote": true,
+    "semi": true,
+    "tabWidth": 4,
+    "trailingComma": "all",
+    "printWidth": 100,
+    "arrowParens": "avoid",
+    "endOfLine": "auto",
+    "bracketSpacing": true
+}

package/README.md

@@ -0,0 +1,3 @@
+# visang-tracker
+
+비상 로그 트래킹

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "visang-tracker",
+    "version": "1.0.0",
+    "description": "",
+    "main": "index.js",
+    "scripts": {
+        "build": "tsc",
+        "prepare": "npm run build"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "MIT",
+    "devDependencies": {
+        "@types/node": "^22.14.1",
+        "@types/qs": "^6.14.0",
+        "@typescript-eslint/eslint-plugin": "^8.46.2",
+        "@typescript-eslint/parser": "^8.46.2",
+        "eslint": "^9.38.0",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-react": "^7.37.5",
+        "eslint-plugin-react-hooks": "^7.0.0",
+        "prettier": "^3.6.2",
+        "typescript": "^5.8.3"
+    },
+    "dependencies": {
+        "axios": "^1.12.2",
+        "googleapis": "^148.0.0",
+        "qs": "^6.14.0",
+        "url": "^0.11.4"
+    }
+}

package/src/api/index.ts

@@ -0,0 +1,119 @@
+import axios, { AxiosResponse } from 'axios';
+import log from './log';
+import qs from 'qs';
+
+export default {
+    log,
+};
+
+const url = {
+    logApi: () => {
+        return process.env.AIDT_LOG_URL;
+    },
+};
+
+const getBaseUrl = (apiServer: ApiServerType) => {
+    switch (apiServer) {
+        default:
+        case 'log':
+            return url.logApi();
+    }
+};
+
+type ApiServerType =
+    | 'vcloudapi'
+    | 'lcmsapi'
+    | 'medianaviapi'
+    | 'tutorus'
+    | 'keris'
+    | 'nats'
+    | 'aidtoperation'
+    | 'log';
+type MethodType = 'get' | 'put' | 'post' | 'delete' | 'multipart';
+
+const log_request = async <Res>(
+    apiServer: ApiServerType,
+    method: MethodType,
+    endpoint: string,
+    data: any,
+): Promise<Res | undefined> => {
+    // AxiosResponse.data 반환
+    const res = await _log_request<Res>(apiServer, method, endpoint, data);
+    return res ? (res.data as Res) : undefined;
+};
+
+const _log_request = async <Res>(
+    apiServer: ApiServerType,
+    method: MethodType,
+    endpoint: string,
+    data: any,
+): Promise<AxiosResponse<Res> | undefined> => {
+    // AxiosResponse 반환
+    const baseURL = getBaseUrl(apiServer);
+
+    let headers: any = {
+        'Content-Type': method == 'multipart' ? 'multipart/form-data' : 'application/json',
+        accept: 'application/json',
+    };
+
+    const instance = axios.create({
+        baseURL,
+        headers,
+        paramsSerializer: {
+            encode: val => {
+                return encodeURIComponent(val)
+                    .replace(/%40/gi, '@')
+                    .replace(/%3A/gi, ':')
+                    .replace(/%24/g, '$')
+                    .replace(/%2C/gi, ',')
+                    .replace(/%20/g, '+')
+                    .replace(/%5B/gi, '[')
+                    .replace(/%5D/gi, ']');
+            },
+            serialize: params => {
+                return qs.stringify(params, { arrayFormat: 'brackets' });
+            },
+        },
+    });
+    let axiosResponse: AxiosResponse<Res>;
+
+    try {
+        switch (method) {
+            case 'get':
+                axiosResponse = await instance.get<Res>(endpoint, { params: data });
+                break;
+            case 'post':
+            case 'multipart':
+                axiosResponse = await instance.post<Res>(endpoint, data);
+                break;
+            case 'put':
+                axiosResponse = await instance.put<Res>(endpoint, data);
+                break;
+            case 'delete':
+                axiosResponse = await instance.delete<Res>(endpoint, { params: data });
+                break;
+        }
+
+        return axiosResponse;
+    } catch (e) {
+        // commonUtil.log('[NAVI] api response exception', e);
+    }
+};
+
+// const sendTraceLogAck=(hash)=>{
+//     if(hash){
+//         commonStore.sendTraceLogAck(hash)
+//     }
+// }
+
+export const LogApiUtil = {
+    post: async <Res>(endpoint: string, data: any): Promise<Res | undefined> =>
+        log_request<Res>('log', 'post', endpoint, data),
+};
+
+// export const KerisMockupApiUtil = {
+//     get: async <Res>(endpoint: string, data: any): Promise<Res | undefined> => axios_request<Res>('vcloudapi', "get", endpoint, data),
+//     post: async <Res>(endpoint: string, data: any): Promise<Res | undefined> => axios_request<Res>('vcloudapi', "post", endpoint, data),
+//     put: async <Res>(endpoint: string, data: any): Promise<Res | undefined> => axios_request<Res>('vcloudapi', "put", endpoint, data),
+//     delete: async <Res>(endpoint: string, data: any): Promise<Res | undefined> => axios_request<Res>('vcloudapi', "delete", endpoint, data),
+// }

package/src/api/log/index.ts

@@ -0,0 +1,7 @@
+import { LogApiUtil } from '../index';
+
+export default {
+    sendTraceLog: async (param: any) => {
+        return LogApiUtil.post('/logs/sendTraceLog', param);
+    },
+};

package/src/index.ts

@@ -0,0 +1,91 @@
+import api from '../src/api';
+
+type TraceLogItem = Record<string, any>;
+
+const LOG_BATCH_MAX = 20;
+const LOG_FLUSH_INTERVAL_MS = 10000;
+const LOG_STORAGE_KEY = 'aidt_trace_log_queue_v1';
+
+let logQueue: TraceLogItem[] = [];
+let flushTimerId: number | null = null;
+let isFlushing = false;
+
+try {
+    const saved = localStorage.getItem(LOG_STORAGE_KEY);
+    if (saved) {
+        const parsed = JSON.parse(saved);
+        if (Array.isArray(parsed)) {
+            logQueue = parsed;
+        }
+    }
+} catch (e) {
+    console.log(e);
+}
+
+export function initLog() {}
+
+const persistQueue = () => {
+    try {
+        localStorage.setItem(LOG_STORAGE_KEY, JSON.stringify(logQueue));
+    } catch {
+        /* storage may be full or unavailable */
+    }
+};
+
+const transportBatch = async (batch: TraceLogItem[]) => {
+    // Prefer bulk endpoint if provided by api.log
+    const maybeBulk = (api as any)?.log?.sendTraceLogs;
+    if (typeof maybeBulk === 'function') {
+        return maybeBulk(batch);
+    }
+    await api.log.sendTraceLog(batch);
+};
+
+const flushLogQueue = async () => {
+    if (isFlushing) return;
+    if (logQueue.length === 0) return;
+
+    isFlushing = true;
+    try {
+        while (logQueue.length > 0) {
+            const batch = logQueue.splice(0, LOG_BATCH_MAX);
+            await transportBatch(batch);
+            persistQueue();
+        }
+    } finally {
+        isFlushing = false;
+    }
+};
+
+const scheduleFlush = () => {
+    if (flushTimerId != null) return;
+    flushTimerId = window.setInterval(() => {
+        if (document.visibilityState === 'visible') {
+            flushLogQueue();
+        }
+    }, LOG_FLUSH_INTERVAL_MS);
+};
+
+const enqueueTraceLog = (item: TraceLogItem) => {
+    logQueue.push(item);
+    persistQueue();
+
+    if (logQueue.length >= LOG_BATCH_MAX) {
+        flushLogQueue();
+    } else {
+        scheduleFlush();
+    }
+};
+
+window.addEventListener('visibilitychange', () => {
+    flushLogQueue();
+});
+
+const sendTraceLogDebug = (errorLog: any) => {
+    enqueueTraceLog(errorLog);
+};
+
+export default {
+    initLog,
+    sendTraceLogDebug,
+};

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "ESNext",
+        "declaration": true,
+        "outDir": "dist",
+        "strict": true,
+        "esModuleInterop": true,
+        "moduleResolution": "node",
+        "skipLibCheck": true
+    },
+    "include": ["src"]
+}