@zxhy-npm/send-sls-logger 0.0.1 → 1.0.1

package/lib/index.d.ts

@@ -1,70 +1,4 @@
 import { WebTrackerBrowserOptions } from "@aliyun-sls/web-track-browser";
-
-interface StringObject {
-  [name: string]: string | Function;
-}
-
-/** 对最终发送的日志进行兜底处理，只能在init中使用 */
-type FormatResult = (result: any) => any;
-
-interface initConfig {
-  debug?: boolean;
-  /** 日志默认值，可以配置字符串或者function，如果是function，每次发送日志都会执行，通常用于获取当前页面的url等 */
-  defaultData?: StringObject;
-  /** 设置关键字列表，用于排除一些日志，如果日志中包含配置的这些关键字，则不发送日志 */
-  defaultExclude?: string[];
-  options?: WebTrackerBrowserOptions;
-  /** 最大字符长度，如果关键字里包含token，则不进行截断 */
-  strMaxLength?: number;
-  /** 对最终发送的日志进行兜底处理，只能在init中使用 */
-  userFormatResult?: FormatResult;
-}
-
-export = slsLog;
-export as namespace slsLog;
-
-/**
- * PC端sls日志组件，使用init初始化项目，填入 options(host、project、logstore)；
- * 在后续使用的时候，直接调用error｜warn｜log｜into向sls发送日志
- */
-declare namespace slsLog {
-  /**
-   * @name 发送error日志
-   * 接收两个参数，
-   * @param log string | StringObject
-   * @param format 整理即将发送的，返回要发送的日志结果
-   * */
-  function error(str: string | StringObject, format?: FormatResult): void;
-  /**
-   * @name 发送警告日志
-   * 接收两个参数，
-   * @param log string | StringObject
-   * @param format 整理即将发送的，返回要发送的日志结果
-   * */
-  function warn(str: string | StringObject, format?: FormatResult): void;
-  /**
-   * @name 发送普通日志
-   * 接收两个参数，
-   * @param log string | StringObject
-   * @param format 整理即将发送的，返回要发送的日志结果
-   * */
-  function log(str: string | StringObject, format?: FormatResult): void;
-  /**
-   * @name 发送普通日志
-   * 接收两个参数，
-   * @param log string | StringObject
-   * @param format 整理即将发送的，返回要发送的日志结果
-   * */
-  function info(str: string | StringObject, format?: FormatResult): void;
-  /**
-   * @name 初始化init
-   * @description 可以多次调用，在发送日志之前，一定要初始化过 options(host、project、logstore) 内容
-   * @param debug 是否开启debug模式
-   * @param defaultData 日志默认值，可以配置字符串或者function，如果是function，每次发送日志都会执行，通常用于获取当前页面的url等
-   * @param defaultExclude 设置关键字列表，用于排除一些日志，如果日志中包含配置的这些关键字，则不发送日志
-   * @param options host、project、logstore
-   * @param strMaxLength 是否开启debug模式 最大字符长度，如果关键字里包含token，则不进行截断
-   * @param userFormatResult 对最终发送的日志进行兜底处理，只能在init中使用
-   */
-  function init(config: initConfig): void;
-}
+import DefaultLog, { InitConfig } from "./init";
+declare const SLSLog: (config: InitConfig<WebTrackerBrowserOptions>) => DefaultLog<WebTrackerBrowserOptions>;
+export default SLSLog;

package/lib/index.js

@@ -1,6 +1,9 @@
-import SlsTracker from "@aliyun-sls/web-track-browser";
-import logger from "./init";
-
-const init = logger.logInit(SlsTracker);
-
-export default { ...logger, init };
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web_track_browser_1 = __importDefault(require("@aliyun-sls/web-track-browser"));
+const init_1 = __importDefault(require("./init"));
+const SLSLog = (config) => new init_1.default(web_track_browser_1.default, config);
+exports.default = SLSLog;

package/lib/init.d.ts

@@ -0,0 +1,54 @@
+interface StringObject {
+    [name: string]: any;
+}
+/** 对最终发送的日志进行兜底处理，只能在init中使用 */
+type FormatResult = (result: any) => any;
+interface LogOptions {
+    host: string;
+    project: string;
+    logstore: string;
+    time?: number;
+    count?: number;
+}
+export interface InitConfig<T extends LogOptions> {
+    /** 是否开启debug模式 */
+    debug?: boolean;
+    /** 日志默认值，可以配置字符串或者function，如果是function，每次发送日志都会执行，通常用于获取当前页面的url等 */
+    defaultData?: StringObject;
+    /** 设置关键字列表，用于排除一些日志，如果日志中包含配置的这些关键字，则不发送日志 */
+    defaultExclude?: string[];
+    options?: T;
+    /** 最大字符长度，如果关键字里包含token，则不进行截断 */
+    strMaxLength?: number;
+    /** 对最终发送的日志进行兜底处理，只能在init中使用 */
+    userFormatResult?: FormatResult;
+}
+declare class DefaultLog<T extends LogOptions> {
+    opts: {
+        host: string;
+        project: string;
+        logstore: string;
+        time: number;
+        count: number;
+    };
+    private defaultLogData;
+    private exclude;
+    private tracker;
+    private userFormatResult?;
+    private debug;
+    private maxLength;
+    private Tracker;
+    constructor(Tracker: new (config: T) => any, config: InitConfig<T>);
+    /** init 可以多次调用，最好在初次，填入 options 内容 */
+    init(config: InitConfig<T>): void;
+    private formatDataMaxLength;
+    private formatFunctionObj;
+    private formatLogData;
+    private sendResult;
+    private send;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    log: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+}
+export default DefaultLog;

package/lib/init.js

@@ -1,131 +1,129 @@
-const opts = {
-	host: "", // 所在地域的服务入口。例如cn-hangzhou.log.aliyuncs.com
-	project: "", // Project名称。
-	logstore: "", // Logstore名称。
-	time: 5, // 发送日志的时间间隔，默认是10秒。
-	count: 10, // 发送日志的数量大小，默认是10条。
-};
-const defaultLogData = {};
-const exclude = [];
-let tracker;
-let userFormatResult;
-let debug;
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const getType = (val) => {
-	return Object.prototype.toString.call(val).toLocaleLowerCase().slice(8, -1);
-};
-
-let maxLength = 200;
-const formatDataMaxLength = (data) => {
-	if (getType(data) === "object") {
-		return Object.keys(data).reduce((curr, key) => {
-			curr[key] = /token/.test(key)
-				? data[key]
-				: formatDataMaxLength(data[key]);
-			return curr;
-		}, {});
-	} else if (getType(data) === "array") {
-		return data.map((i) => formatDataMaxLength(i));
-	} else if (getType(data) === "string" && data.length > maxLength) {
-		return `${data.slice(0, maxLength)}...${data.length - maxLength}个字已忽略`;
-	} else {
-		return data;
-	}
-};
-
-const formatFunctionObj = (data) => {
-	if (getType(data) === "object") {
-		return Object.keys(data).reduce((curr, key) => {
-			curr[key] = formatFunctionObj(data[key]);
-			return curr;
-		}, {});
-	} else if (getType(data) === "array") {
-		return data.map((i) => formatFunctionObj(i));
-	} else if (getType(data) === "function") {
-		return data();
-	} else {
-		return data;
-	}
-};
-const formatLogData = (data, type = "log") => {
-	const result = { ...defaultLogData, type };
-	if (typeof data === "string") {
-		Object.assign(result, { data });
-	} else if (typeof data === "object") {
-		Object.assign(result, data);
-	}
-	return formatFunctionObj(result);
-};
-
-const send = (type) => {
-	return function (err, activeFormatResult) {
-		let data = {};
-		if (typeof err === "string") {
-			data.msg = err;
-		} else if (typeof err === "object") {
-			data = { ...err };
-		}
-
-		const result = formatLogData(data, type);
-		const isExcludeMsg = Object.keys(result).find((key) => {
-			return exclude.find((i) => new RegExp(i, "g").test(result[key]));
-		});
-
-		if (!opts.host || !opts.project || !opts.logstore) {
-			return console.warn("日志初始化需要配置options", result);
-		}
-		let formatResultObj = formatDataMaxLength(result);
-
-		if (getType(userFormatResult) === "function") {
-			formatResultObj = userFormatResult(formatResultObj) || formatResultObj;
-		}
-
-		if (getType(activeFormatResult) === "function") {
-			formatResultObj = activeFormatResult(formatResultObj) || formatResultObj;
-		}
-
-		if (isExcludeMsg) {
-			debug && console.log(`logger ${type}`, formatResultObj);
-			return;
-		}
-		tracker.send(formatResultObj);
-	};
-};
-
-const error = send("error");
-const warn = send("warn");
-const log = send("info");
-const info = send("info");
-
-const logInit = (Tracker) => {
-	return (config) => {
-		const {
-			defaultData = {},
-			defaultExclude = [],
-			options = {},
-			strMaxLength = maxLength,
-			debug: defaultDebug = debug,
-			userFormatResult: defaultUserFormatResult = userFormatResult,
-		} = config;
-
-		if (defaultDebug !== undefined) {
-			debug = defaultDebug;
-		}
-		userFormatResult = defaultUserFormatResult;
-		Object.assign(defaultLogData, defaultData);
-		Object.assign(opts, options);
-		if (options.host && options.logstore && options.project) {
-			tracker = new Tracker(opts);
-		}
-		maxLength = strMaxLength;
-		exclude.push(...defaultExclude);
-	};
-};
-
-export default {
-	error,
-	warn,
-	log,
-	info,
-	logInit,
+    return Object.prototype.toString.call(val).toLocaleLowerCase().slice(8, -1);
 };
+const defaultMaxLength = 200;
+class DefaultLog {
+    opts = {
+        host: '',
+        project: '',
+        logstore: '',
+        time: 5,
+        count: 10, // 发送日志的数量大小，默认是10条。
+    };
+    defaultLogData = {};
+    exclude = [];
+    tracker;
+    userFormatResult;
+    debug = false;
+    maxLength = 200;
+    Tracker;
+    constructor(Tracker, config) {
+        this.Tracker = Tracker;
+        this.init(config);
+    }
+    /** init 可以多次调用，最好在初次，填入 options 内容 */
+    init(config) {
+        const { defaultData = {}, defaultExclude = [], options, strMaxLength = defaultMaxLength, debug: defaultDebug = false, userFormatResult: defaultUserFormatResult = (_) => _, } = config;
+        if (defaultDebug !== undefined) {
+            this.debug = defaultDebug;
+        }
+        this.userFormatResult = defaultUserFormatResult;
+        Object.assign(this.defaultLogData, defaultData);
+        Object.assign(this.opts, options);
+        if (options?.host && options.logstore && options.project) {
+            this.tracker = new this.Tracker(options);
+        }
+        this.maxLength = strMaxLength;
+        this.exclude.push(...defaultExclude);
+    }
+    formatDataMaxLength(data) {
+        const { formatDataMaxLength, maxLength } = this;
+        if (getType(data) === 'object') {
+            return Object.keys(data).reduce((curr, key) => {
+                curr[key] = /token/.test(key) ? data[key] : formatDataMaxLength.call(this, data[key]);
+                return curr;
+            }, {});
+        }
+        else if (getType(data) === 'array') {
+            return data.map((i) => formatDataMaxLength.call(this, i));
+        }
+        else if (getType(data) === 'string' && data.length > maxLength) {
+            return `${data.slice(0, maxLength)}...${data.length - maxLength}个字已忽略`;
+        }
+        else {
+            return data;
+        }
+    }
+    formatFunctionObj(data) {
+        const { formatFunctionObj } = this;
+        if (getType(data) === 'object') {
+            return Object.keys(data).reduce((curr, key) => {
+                curr[key] = formatFunctionObj.call(this, data[key]);
+                return curr;
+            }, {});
+        }
+        else if (getType(data) === 'array') {
+            return data.map((i) => formatFunctionObj.call(this, i));
+        }
+        else if (getType(data) === 'function') {
+            return data();
+        }
+        else {
+            return data;
+        }
+    }
+    formatLogData(data, type = 'log') {
+        console.log('formatLogData', this);
+        const { defaultLogData, formatFunctionObj } = this;
+        const result = { ...defaultLogData, type };
+        if (typeof data === 'string') {
+            Object.assign(result, { data });
+        }
+        else if (typeof data === 'object') {
+            Object.assign(result, data);
+        }
+        return formatFunctionObj.call(this, result);
+    }
+    sendResult(type, err, activeFormatResult) {
+        const { opts, formatLogData, formatDataMaxLength, userFormatResult, debug, tracker, exclude } = this;
+        let data = {};
+        if (typeof err === 'string') {
+            data.msg = err;
+        }
+        else if (typeof err === 'object') {
+            data = { ...err };
+        }
+        const result = formatLogData.call(this, data, type);
+        const isExcludeMsg = Object.keys(result).find((key) => {
+            return exclude.find((i) => new RegExp(i, 'g').test(result[key]));
+        });
+        if (!opts.host || !opts.project || !opts.logstore) {
+            return console.warn('日志初始化需要配置options', result);
+        }
+        let formatResultObj = formatDataMaxLength.call(this, result);
+        if (getType(userFormatResult) === 'function') {
+            formatResultObj = userFormatResult?.(formatResultObj) || formatResultObj;
+        }
+        if (getType(activeFormatResult) === 'function') {
+            formatResultObj = activeFormatResult?.(formatResultObj) || formatResultObj;
+        }
+        if (isExcludeMsg) {
+            debug && console.log(`logger ${type}`, formatResultObj);
+            return;
+        }
+        tracker.send(formatResultObj);
+    }
+    send(type) {
+        const self = this;
+        return (...args) => {
+            this.sendResult.call(self, type, ...args);
+        };
+    }
+    error = this.send('error');
+    warn = this.send('warn');
+    log = this.send('info');
+    info = this.send('info');
+}
+exports.default = DefaultLog;

package/lib/mini.d.ts

@@ -1,71 +1,3 @@
-import { WebTrackerMiniOptions } from "@aliyun-sls/web-track-mini";
-interface StringObject {
-  [name: string]: string | Function;
-}
-
-/** 对最终发送的日志进行兜底处理，只能在init中使用 */
-type FormatResult = (result: any) => any;
-
-/** init 可以多次调用，最好在初次，填入 options 内容 */
-interface initConfig {
-  /** 是否开启debug模式 */
-  debug?: boolean;
-  /** 日志默认值，可以配置字符串或者function，如果是function，每次发送日志都会执行，通常用于获取当前页面的url等 */
-  defaultData?: StringObject;
-  /** 设置关键字列表，用于排除一些日志，如果日志中包含配置的这些关键字，则不发送日志 */
-  defaultExclude?: string[];
-  options?: WebTrackerMiniOptions;
-  /** 最大字符长度，如果关键字里包含token，则不进行截断 */
-  strMaxLength?: number;
-  /** 对最终发送的日志进行兜底处理，只能在init中使用 */
-  userFormatResult?: FormatResult;
-}
-
-export = miniLog;
-export as namespace miniLog;
-
-/**
- * 小程序日志，使用init初始化项目，填入 options(host、project、logstore)，init可以多次调用，填入defaultData等默认信息；
- * 在后续使用的时候，直接调用error｜warn｜log｜into向sls发送日志
- */
-declare namespace miniLog {
-  /**
-   * @name 发送error日志
-   * 接收两个参数，
-   * @param log string | StringObject
-   * @param format 整理即将发送的，返回要发送的日志结果
-   * */
-  function error(str: string | StringObject, format?: FormatResult): void;
-  /**
-   * @name 发送警告日志
-   * 接收两个参数，
-   * @param log string | StringObject
-   * @param format 整理即将发送的，返回要发送的日志结果
-   * */
-  function warn(str: string | StringObject, format?: FormatResult): void;
-  /**
-   * @name 发送普通日志
-   * 接收两个参数，
-   * @param log string | StringObject
-   * @param format 整理即将发送的，返回要发送的日志结果
-   * */
-  function log(str: string | StringObject, format?: FormatResult): void;
-  /**
-   * @name 发送普通日志
-   * 接收两个参数，
-   * @param log string | StringObject
-   * @param format 整理即将发送的，返回要发送的日志结果
-   * */
-  function info(str: string | StringObject, format?: FormatResult): void;
-  /**
-   * @name 初始化init
-   * @description 可以多次调用，在发送日志之前，一定要初始化过 options(host、project、logstore) 内容
-   * @param debug 是否开启debug模式
-   * @param defaultData 日志默认值，可以配置字符串或者function，如果是function，每次发送日志都会执行，通常用于获取当前页面的url等
-   * @param defaultExclude 设置关键字列表，用于排除一些日志，如果日志中包含配置的这些关键字，则不发送日志
-   * @param options host、project、logstore
-   * @param strMaxLength 是否开启debug模式 最大字符长度，如果关键字里包含token，则不进行截断
-   * @param userFormatResult 对最终发送的日志进行兜底处理，只能在init中使用
-   */
-  function init(config: initConfig): void;
-}
+import DefaultLog, { InitConfig } from "./init";
+declare const MiniInit: (config: InitConfig<any>) => DefaultLog<import("@aliyun-sls/web-track-mini").WebTrackerMiniOptions>;
+export default MiniInit;

package/lib/mini.js

@@ -1,6 +1,9 @@
-import SlsMiniTracker from "@aliyun-sls/web-track-mini";
-import logger from "./init";
-
-const init = logger.logInit(SlsMiniTracker);
-
-export default { ...logger, init };
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web_track_mini_1 = __importDefault(require("@aliyun-sls/web-track-mini"));
+const init_1 = __importDefault(require("./init"));
+const MiniInit = (config) => new init_1.default(web_track_mini_1.default, config);
+exports.default = MiniInit;

package/package.json

@@ -1,30 +1,34 @@
 {
-  "name": "@zxhy-npm/send-sls-logger",
-  "version": "0.0.1",
-  "description": "阿里云sls的logger发送",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "files": [
-    "lib"
-  ],
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
-  "exports": {
-    ".": "./lib/index.js",
-    "./mini": "./lib/mini.js"
-  },
-  "keywords": [
-    "logger",
-    "sls"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "author": "liukai",
-  "license": "ISC",
-  "dependencies": {
-    "@aliyun-sls/web-track-browser": "^0.0.3",
-    "@aliyun-sls/web-track-mini": "^0.0.2"
-  }
+	"name": "@zxhy-npm/send-sls-logger",
+	"version": "1.0.1",
+	"description": "阿里云sls的logger发送",
+	"scripts": {
+		"build": "rm -rf lib && tsc"
+	},
+	"files": [
+		"lib"
+	],
+	"main": "lib/index.js",
+	"types": "lib/index.d.ts",
+	"exports": {
+		".": "./lib/index.js",
+		"./mini": "./lib/mini.js"
+	},
+	"keywords": [
+		"logger",
+		"sls"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"author": "liukai",
+	"license": "ISC",
+	"devDependencies": {
+		"esbuild": "^0.17.8",
+		"typescript": "^4.9.5"
+	},
+	"dependencies": {
+		"@aliyun-sls/web-track-browser": "^0.0.3",
+		"@aliyun-sls/web-track-mini": "^0.0.2"
+	}
 }

package/readme.md

@@ -1,7 +1,9 @@
 ## PC 使用方式
 
 ```javascript
-import slsLog from "send-sls-logger";
+import SLSLog from '@zxhy-npm/send-sls-logger';
+
+const slsLog = SLSLog({});
 slsLog.init({
   defaultData: logDefaultData, // 默认带的数据
   defaultExclude: ["模拟器", "ResizeObserver"], // 需要排除的数据
@@ -20,7 +22,9 @@ slsLog.info({ msg: "这是一条默认日志" });
 ## 小程序 使用方式
 
 ```javascript
-import miniLog from "send-sls-logger/lib/mini";
+import MiniLog from "@zxhy-npm/send-sls-logger/lib/mini";
+
+const miniLog = MiniLog({});
 miniLog.init({
   defaultData: logDefaultData, // 默认带的数据
   defaultExclude: ["模拟器", "ResizeObserver"], // 需要排除的数据