@lark-apaas/client-toolkit 1.2.1-alpha.16 → 1.2.1-alpha.18

package/lib/utils/axiosConfig.d.ts

@@ -9,7 +9,5 @@ declare module 'axios' {
         _requestUUID?: string;
     }
 }
-/**
- * axios配置内容：拦截器、日志等
- */
-export declare function initAxiosConfig(axiosInstance?: AxiosInstance): AxiosInstance;
+export declare function patchCreate(): void;
+export declare function initAxiosConfig(axiosInstance?: AxiosInstance): void;

package/lib/utils/axiosConfig.js

@@ -1,4 +1,4 @@
-import axios from "axios";
+import axios, { Axios } from "axios";
 import { observable } from "@lark-apaas/observable-web";
 import { logger } from "../apis/logger.js";
 import { getStacktrace } from "../logger/selected-logs.js";
@@ -129,118 +129,106 @@ async function logResponse(ok, responseOrError) {
     });
 }
 const requestStacktraceMap = new Map();
-function initAxiosConfig(axiosInstance) {
-    if (!axiosInstance) axiosInstance = axios;
-    try {
-        if (axiosInstance && !axiosInstance._isTraced) {
-            axiosInstance._isTraced = true;
-            const methodsWithNoData = [
-                'get',
-                'delete',
-                'head',
-                'options'
-            ];
-            const methodsWithData = [
-                'post',
-                'put',
-                'patch',
-                'postForm',
-                'putForm',
-                'patchForm'
-            ];
-            const allMethods = [
-                'request',
-                ...methodsWithNoData,
-                ...methodsWithData
-            ];
-            allMethods.forEach((methodName)=>{
-                const originalMethod = axiosInstance[methodName];
-                if ('function' != typeof originalMethod) return;
-                axiosInstance[methodName] = function() {
-                    const args = Array.prototype.slice.call(arguments);
-                    try {
-                        let config;
-                        let url = '';
-                        let actualMethod = methodName.toUpperCase();
-                        if ('request' === methodName) if ('string' == typeof args[0]) {
-                            url = args[0];
-                            config = args[1] = args[1] || {};
-                        } else {
-                            config = args[0] = args[0] || {};
-                            url = config.url || '';
-                            actualMethod = (config.method || 'GET').toUpperCase();
-                        }
-                        else if (methodsWithNoData.includes(methodName)) {
-                            url = args[0];
-                            config = args[1] = args[1] || {};
-                        } else if (methodsWithData.includes(methodName)) {
-                            url = args[0];
-                            config = args[2] = args[2] || {};
-                        }
-                        if (config && !config.__span) {
-                            const cleanedPath = (url || '').split('?')[0].replace(/^\/spark\/p\/app_\w+/, '') || '/';
-                            const span = observable.startSpan(`${actualMethod} ${cleanedPath}`);
-                            if (span) {
-                                const spanContext = span.spanContext();
-                                if (spanContext && spanContext.traceId) {
-                                    const traceInfo = `${spanContext.traceId}-${spanContext.spanId}`;
-                                    if (!config.headers) config.headers = {};
-                                    config.headers['X-Tt-TraceInfo'] = traceInfo;
-                                    config.__span = span;
-                                }
-                            }
-                        }
-                    } catch (innerError) {
-                        console.error(`Trace wrapper inner error [${methodName}]:`, innerError);
+let isPrototypeInjected = false;
+function injectAxiosPrototype() {
+    if (isPrototypeInjected) return;
+    isPrototypeInjected = true;
+    const originalRequest = Axios.prototype.request;
+    Axios.prototype.request = function(configOrUrl, config) {
+        let finalConfig;
+        if ('string' == typeof configOrUrl) {
+            finalConfig = config || {};
+            finalConfig.url = configOrUrl;
+        } else finalConfig = configOrUrl || {};
+        let span;
+        try {
+            if (!finalConfig.__span) {
+                const url = finalConfig.url || '';
+                const actualMethod = (finalConfig.method || 'GET').toUpperCase();
+                const cleanedPath = url.split('?')[0].replace(/^\/spark\/p\/app_\w+/, '') || '/';
+                span = observable.startSpan(`${actualMethod} ${cleanedPath}`);
+                if (span) {
+                    const spanContext = span.spanContext();
+                    if (spanContext && spanContext.traceId) {
+                        const traceInfo = `${spanContext.traceId}-${spanContext.spanId}`;
+                        if (!finalConfig.headers) finalConfig.headers = {};
+                        finalConfig.headers['X-Tt-TraceInfo'] = traceInfo;
+                        finalConfig.__span = span;
                     }
-                    return originalMethod.apply(this, args);
-                };
-            });
-        }
-    } catch (e) {
-        console.error('Failed to init axios trace config wrapper:', e);
-    }
-    axiosInstance.interceptors.response.use((response)=>{
-        const { __span: span, _startTime: startTime, url = "" } = response.config || {};
-        const method = (response.config.method || 'GET').toUpperCase();
-        const cleanedPath = url.split('?')[0].replace(/^\/spark\/p\/app_\w+/, '') || '/';
-        if (span) {
-            const logData = {
-                method,
-                path: cleanedPath,
-                url: response.request?.responseURL || url || "",
-                duration_ms: startTime ? Date.now() - startTime : void 0,
-                status: response.status
-            };
-            if ('undefined' != typeof navigator) logData.user_agent = navigator.userAgent;
-            if (response.config.data) logData.request_body = response.config.data;
-            if (response.data) logData.response = response.data || {};
-            observable.log('INFO', safeStringify(logData), {}, span);
-            'function' == typeof span.end && span.end();
-        }
-        return response;
-    }, (error)=>{
-        const { config: errorConfig = {}, response: errorResponse = {}, message: errorMessage = '未知错误' } = error;
-        const { __span: span, _startTime: startTime, url = "" } = errorConfig || {};
-        const method = (errorConfig.method || 'GET').toUpperCase();
-        const cleanedPath = url.split('?')[0].replace(/^\/spark\/p\/app_\w+/, '') || '/';
-        if (span) {
-            const logData = {
-                method,
-                path: cleanedPath,
-                url: errorResponse.request?.responseURL || errorConfig.url || "",
-                duration_ms: startTime ? Date.now() - startTime : void 0,
-                status: errorResponse.status || 200,
-                error_message: errorMessage
-            };
-            if ('undefined' != typeof navigator) logData.user_agent = navigator.userAgent;
-            if (errorConfig.data) logData.request_body = errorConfig.data;
-            if (errorResponse.data) logData.response = errorResponse.data || {};
-            observable.log('ERROR', safeStringify(logData), {}, span);
-            'function' == typeof span.end && span.end();
+                }
+            }
+        } catch (e) {
+            console.error('Failed to start axios trace span in prototype:', e);
         }
-        return Promise.reject(error);
-    });
+        const promise = originalRequest.apply(this, arguments);
+        return promise.then((response)=>{
+            try {
+                const currentSpan = response.config?.__span;
+                if (currentSpan) {
+                    const startTime = response.config._startTime;
+                    const url = response.config.url || "";
+                    const method = (response.config.method || 'GET').toUpperCase();
+                    const path = url.split('?')[0] || '/';
+                    const logData = {
+                        method,
+                        path,
+                        url: response.request?.responseURL || url || "",
+                        duration_ms: startTime ? Date.now() - startTime : void 0,
+                        status: response.status
+                    };
+                    if ('undefined' != typeof navigator) logData.user_agent = navigator.userAgent;
+                    if (response.config.data) logData.request_body = response.config.data;
+                    if (response.data) logData.response = response.data || {};
+                    observable.log('INFO', safeStringify(logData), {}, currentSpan);
+                    'function' == typeof currentSpan.end && currentSpan.end();
+                }
+            } catch (e) {
+                console.error('Failed to log success span:', e);
+            }
+            return response;
+        }, (error)=>{
+            try {
+                const errorConfig = error.config || {};
+                const currentSpan = errorConfig.__span;
+                if (currentSpan) {
+                    const errorResponse = error.response || {};
+                    const startTime = errorConfig._startTime;
+                    const url = errorConfig.url || "";
+                    const method = (errorConfig.method || 'GET').toUpperCase();
+                    const path = url.split('?')[0] || '/';
+                    const errorMessage = error.message || '未知错误';
+                    const logData = {
+                        method,
+                        path,
+                        url: errorResponse.request?.responseURL || errorConfig.url || "",
+                        duration_ms: startTime ? Date.now() - startTime : void 0,
+                        status: errorResponse.status || 200,
+                        error_message: errorMessage
+                    };
+                    if ('undefined' != typeof navigator) logData.user_agent = navigator.userAgent;
+                    if (errorConfig.data) logData.request_body = errorConfig.data;
+                    if (errorResponse.data) logData.response = errorResponse.data || {};
+                    observable.log('ERROR', safeStringify(logData), {}, currentSpan);
+                    'function' == typeof currentSpan.end && currentSpan.end();
+                }
+            } catch (e) {
+                console.error('Failed to log error span:', e);
+            }
+            return Promise.reject(error);
+        });
+    };
+}
+function patchCreate() {
+    const originalCreate = axios.create;
+    axios.create = function(config) {
+        injectAxiosPrototype();
+        const instance = originalCreate.call(axios, config);
+        initAxiosConfig(instance);
+        return instance;
+    };
+}
+function initAxiosConfig(axiosInstance) {
+    if (!axiosInstance) axiosInstance = axios;
     axiosInstance.interceptors.request.use((config)=>{
         const requestUUID = crypto.randomUUID();
         if ('production' !== process.env.NODE_ENV) {
@@ -260,13 +248,5 @@ function initAxiosConfig(axiosInstance) {
         logResponse('error', error.response || error);
         return Promise.reject(error);
     });
-    if ('function' == typeof axiosInstance) axiosInstance = new Proxy(axiosInstance, {
-        apply (target, thisArg, args) {
-            const requestMethod = target.request;
-            if ('function' != typeof requestMethod) return Reflect.apply(target, thisArg, args);
-            return requestMethod.apply(target, args);
-        }
-    });
-    return axiosInstance;
 }
-export { initAxiosConfig };
+export { initAxiosConfig, patchCreate };

package/lib/utils/getAxiosForBackend.js

@@ -1,5 +1,5 @@
 import axios from "axios";
-import { initAxiosConfig } from "./axiosConfig.js";
+import { initAxiosConfig, patchCreate } from "./axiosConfig.js";
 let axiosInstance;
 function showToast(message, duration = 3000) {
     return new Promise((resolve)=>{
@@ -54,6 +54,7 @@ function showToast(message, duration = 3000) {
     });
 }
 function getAxiosForBackend() {
+    patchCreate();
     if (!axiosInstance) {
         axiosInstance = axios.create({
             baseURL: process.env.CLIENT_BASE_PATH || '/'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/client-toolkit",
-  "version": "1.2.1-alpha.16",
+  "version": "1.2.1-alpha.18",
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
   "files": [
@@ -88,7 +88,7 @@
     "@data-loom/js": "^0.4.3",
     "@lark-apaas/client-capability": "^0.1.2",
     "@lark-apaas/miaoda-inspector": "^1.0.8",
-    "@lark-apaas/observable-web": "1.0.1-alpha.2",
+    "@lark-apaas/observable-web": "1.0.1-alpha.3",
     "@radix-ui/react-avatar": "^1.1.10",
     "@radix-ui/react-popover": "^1.1.15",
     "@radix-ui/react-slot": "^1.2.3",