app-tracker 1.4.1 → 1.4.2

package/index.d.ts

@@ -0,0 +1,36 @@
+import { LogType } from './log';
+export declare class AppLogger {
+    static sendLogsOnLocal: boolean;
+    private static endpointUrl;
+    private static apiKey;
+    private static logs;
+    private static sendTries;
+    private static maxSendTries;
+    private static isSending;
+    private static maxLogsCount;
+    private static userAgent;
+    private static logLevel;
+    private static sendLogsByTypesImmediately;
+    private static isNode;
+    static init(apiKey: string, config?: AppLoggerConfig): void;
+    static debug(message?: string, ...optionalParams: any[]): void;
+    static info(message?: string, ...optionalParams: any[]): void;
+    static log(message?: string, ...optionalParams: any[]): void;
+    static warn(message?: string, ...optionalParams: any[]): void;
+    static error(message?: string, ...optionalParams: any[]): void;
+    private static addLog;
+    private static logToConsole;
+    private static isRunningLocal;
+    private static sendLogsToServer;
+    private static checkLogType;
+    private static sendLogsToServerCore;
+}
+export declare class AppLoggerConfig {
+    sendLogsOnLocal?: boolean | undefined;
+    endpointUrl?: string | undefined;
+    maxSendTries?: number | undefined;
+    maxLogsCount?: number | undefined;
+    /** Defines which log types should be sent to the server */
+    logLevel?: LogType[] | undefined;
+    sendLogsByTypesImmediately?: LogType[] | undefined;
+}

package/log.d.ts

@@ -0,0 +1,14 @@
+export declare class Log {
+    logType: LogType;
+    message: any;
+    optionalParams: any[];
+    createdAt: Date;
+}
+export declare enum LogType {
+    debug = 0,
+    info = 1,
+    log = 2,
+    warn = 3,
+    error = 4,
+    critical = 5
+}

package/log.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Log {
+    constructor() {
+        this.logType = LogType.log;
+        this.optionalParams = [];
+        this.createdAt = new Date();
+    }
+}
+exports.Log = Log;
+var LogType;
+(function (LogType) {
+    LogType[LogType["debug"] = 0] = "debug";
+    LogType[LogType["info"] = 1] = "info";
+    LogType[LogType["log"] = 2] = "log";
+    LogType[LogType["warn"] = 3] = "warn";
+    LogType[LogType["error"] = 4] = "error";
+    LogType[LogType["critical"] = 5] = "critical";
+})(LogType = exports.LogType || (exports.LogType = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "app-tracker",
-    "version": "1.4.1",
+    "version": "1.4.2",
     "description": "App Tracker for Web-Applications",
     "main": "index.js",
     "scripts": {

package/.prettierrc

@@ -1,5 +0,0 @@
-{
-  "printWidth": 120,
-  "trailingComma": "all",
-  "singleQuote": true
-}

package/lib/README.md

@@ -1 +0,0 @@
-# App Tracker for Web Applications

package/lib/package.json

@@ -1,23 +0,0 @@
-{
-    "name": "app-tracker",
-    "version": "1.4.1",
-    "description": "App Tracker for Web-Applications",
-    "main": "index.js",
-    "scripts": {
-        "build": "tsc && npm run copyFile",
-        "copyFile": "xcopy package.json lib && xcopy README.md lib && npm run terser",
-        "terser": "terser lib/index.js --compress -o lib/index.js",
-        "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
-        "lint": "tslint -p tsconfig.json"
-    },
-    "keywords": [],
-    "author": "Egor Kin",
-    "license": "ISC",
-    "devDependencies": {
-        "@types/node": "^17.0.10",
-        "prettier": "^1.19.1",
-        "tslint": "^5.20.1",
-        "tslint-config-prettier": "^1.18.0",
-        "typescript": "^3.7.3"
-    }
-}

package/src/index.ts

@@ -1,179 +0,0 @@
-import { Log, LogType } from './log';
-const os = require('os');
-
-export class AppLogger {
-
-    public static sendLogsOnLocal: boolean = false;
-    private static endpointUrl: string = 'https://api-app-tracker.azurewebsites.net/';
-    private static apiKey: string = '';
-    private static logs: Log[] = [];
-    private static sendTries: number = 0;
-    private static maxSendTries: number = 5;
-    private static isSending: boolean = false;
-    private static maxLogsCount: number = 10;
-    private static userAgent: string;
-    private static logLevel: LogType[] = [LogType.error];
-    private static sendLogsByTypesImmediately: LogType[] | undefined = [LogType.error];
-    private static isNode = false;
-
-    public static init(apiKey: string, config?: AppLoggerConfig) {
-        this.apiKey = apiKey;
-        if (config) {
-            if (config.endpointUrl) this.endpointUrl = config.endpointUrl;
-            if (config.maxLogsCount) this.maxLogsCount = config.maxLogsCount;
-            if (config.maxSendTries) this.maxSendTries = config.maxSendTries;
-            if (config.sendLogsOnLocal) this.sendLogsOnLocal = config.sendLogsOnLocal;
-            if (config.logLevel) this.logLevel = config.logLevel;
-            if (config.sendLogsByTypesImmediately) this.sendLogsByTypesImmediately = config.sendLogsByTypesImmediately;
-        }
-        this.isNode = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
-        if (!this.isNode)
-            this.userAgent = navigator.userAgent;
-        else {
-            this.userAgent = JSON.stringify(os);
-        }
-        if (apiKey != '' && !this.isNode) {
-            window.addEventListener('beforeunload', (e) => {
-                e.preventDefault();
-                e.returnValue = '';
-                if (!this.isSending) {
-                    const logsToSend = this.logs;
-                    this.isSending = true;
-                    this.logs = [];
-                    AppLogger.sendLogsToServerCore(logsToSend);
-                }
-            });
-        }
-    }
-
-    public static debug(message?: string, ...optionalParams: any[]) {
-        AppLogger.addLog(LogType.debug, message, optionalParams);
-    }
-
-    public static info(message?: string, ...optionalParams: any[]) {
-        AppLogger.addLog(LogType.info, message, optionalParams);
-    }
-
-    public static log(message?: string, ...optionalParams: any[]) {
-        AppLogger.addLog(LogType.log, message, optionalParams);
-    }
-
-    public static warn(message?: string, ...optionalParams: any[]) {
-        AppLogger.addLog(LogType.warn, message, optionalParams);
-    }
-
-    public static error(message?: string, ...optionalParams: any[]) {
-        AppLogger.addLog(LogType.error, message, optionalParams);
-    }
-
-    private static addLog(type: LogType, message: string | undefined, optionalParams: any[]) {
-        if (this.checkLogType(type)) {
-            if (this.isRunningLocal() && !this.sendLogsOnLocal) {
-                AppLogger.logToConsole(type, message, optionalParams);
-            } else {
-                AppLogger.sendLogsToServer(type, message, optionalParams);
-            }
-        } else {
-            AppLogger.logToConsole(type, message, optionalParams);
-        }
-    }
-
-    private static logToConsole(type: LogType, message: string | undefined, optionalParams: any[]) {
-        switch (type) {
-            case LogType.debug:
-                console.debug(message, optionalParams);
-                break;
-            case LogType.error:
-                console.error(message, optionalParams);
-                break;
-            case LogType.info:
-                console.info(message, optionalParams);
-                break;
-            case LogType.log:
-                console.log(message, optionalParams);
-                break;
-            case LogType.warn:
-                console.warn(message, optionalParams);
-                break;
-            default:
-                console.warn("Unkown LogType: ", type);
-                break;
-        }
-    }
-
-    private static isRunningLocal(): boolean {
-        return this.isNode ? os.hostname().indexOf("local") > -1 : window.location.href.indexOf('localhost') > -1;
-    }
-
-    private static sendLogsToServer(type: LogType, message?: string, ...optionalParams: any[][]) {
-        const log = { logType: type, message: message, optionalParams: [], createdAt: new Date() } as Log;
-        optionalParams.forEach(op => op.forEach(o => log.optionalParams.push(o)));
-        this.logs.push(log);
-        if ((this.logs.length >= this.maxLogsCount && !this.isSending) ||
-            ((this.sendLogsByTypesImmediately?.find(l => l == type) || type == LogType.critical) != null && !this.isSending)) {
-            const logsToSend = this.logs;
-            this.logs = [];
-            this.isSending = true;
-            AppLogger.sendLogsToServerCore(logsToSend);
-        }
-    }
-
-    private static checkLogType(type: LogType): boolean {
-        if (this.logLevel.find(l => l === type) != null || type === LogType.critical) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-
-    private static async sendLogsToServerCore(logsToSend: Log[]) {
-        if (this.sendTries < this.maxSendTries) {
-            try {
-                const last = this.endpointUrl.charAt(this.endpointUrl.length - 1);
-                const response = await fetch(`${this.endpointUrl}${last === '/' ? 'logs/createLog' : '/logs/createLog'}`,
-                    {
-                        method: 'POST',
-                        headers: {
-                            'Accept': 'application/json',
-                            'Content-Type': 'application/json',
-                            'X-Auth-Key': this.apiKey
-                        },
-                        body: JSON.stringify({ logs: logsToSend, userAgent: this.userAgent }, (key: string, value: any) => {
-                            if (value instanceof Error) {
-                                let error: any = <any>{};
-
-                                Object.getOwnPropertyNames(value).forEach(function (key) {
-                                    error[key] = (<any>value)[key];
-                                });
-                                return error;
-                            }
-                            return value;
-                        })
-                    });
-
-                logsToSend = [];
-                this.isSending = false;
-            } catch (error) {
-                this.sendTries++;
-                setTimeout(() => {
-                    AppLogger.sendLogsToServerCore(logsToSend);
-                }, 10000);
-            }
-        } else {
-            this.sendTries = 0;
-            this.isSending = false;
-            console.error('AppLogger: Could not send Logs to Server');
-        }
-    }
-}
-
-export class AppLoggerConfig {
-    public sendLogsOnLocal?: boolean | undefined;
-    public endpointUrl?: string | undefined;
-    public maxSendTries?: number | undefined;
-    public maxLogsCount?: number | undefined = 5;
-    /** Defines which log types should be sent to the server */
-    public logLevel?: LogType[] | undefined;
-    public sendLogsByTypesImmediately?: LogType[] | undefined = [LogType.error];
-}

package/src/log.ts

@@ -1,8 +0,0 @@
-export class Log {
-  public logType: LogType = LogType.log;
-  public message: any;
-  public optionalParams: any[] = [];
-  public createdAt: Date = new Date();
-}
-
-export enum LogType { debug, info, log, warn, error, critical }

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es6",
-        "module": "commonjs",
-        "declaration": true,
-        "outDir": "./lib",
-        "strict": true
-    },
-    "include": [
-        "src"
-    ],
-    "exclude": [
-        "node_modules",
-        "**/__tests__/*"
-    ]
-}

package/tslint.json

@@ -1,9 +0,0 @@
-{
-    "extends": [
-        "tslint:recommended",
-        "tslint-config-prettier"
-    ],
-    "rules": {
-        "no-console": false
-    }
-}