@oneteme/inspect-ng-collector 0.0.1

package/README.md

@@ -0,0 +1,24 @@
+# InspectNgCollector
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 17.3.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project inspect-ng-collector` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project inspect-ng-collector`.
+> Note: Don't forget to add `--project inspect-ng-collector` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build inspect-ng-collector` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build inspect-ng-collector`, go to the dist folder `cd dist/inspect-ng-collector` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test inspect-ng-collector` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/esm2022/lib/http-interceptor.service.mjs

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { tap, finalize } from 'rxjs/operators';
+import { dateNow } from './util';
+import * as i0 from "@angular/core";
+import * as i1 from "./route-tracer.service";
+export class HttpInterceptorService {
+    constructor(routerTracerService) {
+        this.routerTracerService = routerTracerService;
+    }
+    intercept(req, next) {
+        const start = dateNow();
+        let status, responseBody = '', exception;
+        let id;
+        return next.handle(req).pipe(tap((event) => {
+            if (event instanceof HttpResponse) {
+                status = +event.status;
+                responseBody = event.body;
+                id = getReqid(event.headers);
+            }
+        }, error => {
+            console.log(error);
+            id = getReqid(error.headers);
+            status = +error.status;
+            exception = {
+                type: error.error.error,
+                message: error.error.message
+            };
+        }), finalize(() => {
+            const url = toHref(req.urlWithParams);
+            this.routerTracerService.getCurrentSession().restRequests.push({
+                id: id,
+                method: req.method,
+                protocol: url.protocol.slice(0, -1),
+                host: exctractHost(url.host),
+                port: +url.port,
+                path: url.pathname,
+                query: url.search.slice(1, url.search.length),
+                contentType: req.responseType,
+                authScheme: extractAuthScheme(req.headers),
+                status: +status,
+                inDataSize: sizeOf(responseBody),
+                ouDataSize: sizeOf(req.body),
+                start: start,
+                end: dateNow(),
+                exception: exception
+            });
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: HttpInterceptorService, deps: [{ token: i1.RouteTracerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: HttpInterceptorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: HttpInterceptorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.RouteTracerService }] });
+function toHref(url) {
+    const href = document.createElement('a');
+    href.setAttribute('href', url);
+    return href;
+}
+function exctractHost(path) {
+    const portregex = /:\d+/;
+    return path.replace(portregex, '');
+}
+function extractAuthScheme(headers) {
+    return headers.has('authorization')
+        ? headers.get('authorization').match(/^(\w+) /)?.at(1)
+        : undefined;
+}
+function getReqid(headers) {
+    return headers.has('x-tracert')
+        ? headers.get('x-tracert')
+        : undefined;
+}
+function sizeOf(body) {
+    return body ? JSON.stringify(body).length : 0;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/ng-collector.module.mjs

@@ -0,0 +1,46 @@
+import { NgModule, APP_INITIALIZER } from '@angular/core';
+import { HTTP_INTERCEPTORS, } from '@angular/common/http';
+import { HttpInterceptorService } from './http-interceptor.service';
+import { RouteTracerService } from './route-tracer.service';
+import { getNumberOrCall, logTraceapi, requirePostitiveValue, validate, HOST_PATERN, PATH_PATERN, getStringOrCall } from './util';
+import { SessionManager } from './session-manager.service';
+import * as i0 from "@angular/core";
+export class NgCollectorModule {
+    static forRoot(host, configuration) {
+        if (configuration?.enabled
+            && validate(host, HOST_PATERN)
+            && validate(getStringOrCall(configuration?.sessionApi), PATH_PATERN)
+            && validate(getStringOrCall(configuration?.instanceApi), PATH_PATERN)) {
+            if (!requirePostitiveValue(getNumberOrCall(configuration?.delay), "delay") ||
+                !requirePostitiveValue(getNumberOrCall(configuration?.bufferMaxSize), "bufferMaxSize")) {
+                logTraceapi('warn', 'invalid Configuration, Ng-collector is disabled');
+                return { ngModule: NgCollectorModule };
+            }
+            return {
+                ngModule: NgCollectorModule,
+                providers: [
+                    RouteTracerService,
+                    SessionManager,
+                    { provide: APP_INITIALIZER, useFactory: initializeRoutingEvents, deps: [RouteTracerService], multi: true },
+                    { provide: HTTP_INTERCEPTORS, useClass: HttpInterceptorService, multi: true },
+                    { provide: 'config', useValue: configuration },
+                    { provide: 'host', useValue: host }
+                ]
+            };
+        }
+        return {
+            ngModule: NgCollectorModule
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: NgCollectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.11", ngImport: i0, type: NgCollectorModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: NgCollectorModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: NgCollectorModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+export function initializeRoutingEvents(routeTracerService) {
+    return () => routeTracerService.initialize();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/route-tracer.service.mjs

@@ -0,0 +1,70 @@
+import { Inject, Injectable } from "@angular/core";
+import { NavigationEnd, NavigationStart } from "@angular/router";
+import { dateNow, getRegArrOrCall, getStringOrCall, logTraceapi, prettySessionFormat } from "./util";
+import { SessionManager } from "./session-manager.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+const SLASH = '/';
+export class RouteTracerService {
+    constructor(router, config, host) {
+        this.router = router;
+        this.beforeUnloadHandler = (event) => {
+            this.currentSession.end = dateNow();
+            if (this.excludeList.every((e) => !e.test(this.currentSession.location))) {
+                this.sessionManager.addSessions(this.currentSession); //force 
+                this.sessionManager.sendSessions();
+            }
+        };
+        this.sessionManager = new SessionManager();
+        this.excludeList = getRegArrOrCall(config.exclude);
+        this.sessionManager.initialize(config, host);
+        this.user = getStringOrCall(config.user);
+    }
+    ngOnDestroy() {
+        window.removeEventListener('beforeunload', this.beforeUnloadHandler);
+    }
+    initialize() {
+        logTraceapi('log', 'initialize');
+        window.addEventListener('beforeunload', this.beforeUnloadHandler);
+        this.router.events.subscribe(event => {
+            if (event instanceof NavigationStart) {
+                const now = dateNow();
+                if (this.currentSession) {
+                    this.currentSession.end = dateNow();
+                    if (this.excludeList.every((e) => !e.test(this.currentSession.location))) {
+                        this.sessionManager.addSessions(this.currentSession);
+                    }
+                    logTraceapi('log', prettySessionFormat(this.currentSession));
+                }
+                this.currentSession = {
+                    '@type': "main",
+                    user: this.user,
+                    start: now,
+                    type: "VIEW",
+                    location: event.url,
+                    restRequests: []
+                };
+            }
+            if (event instanceof NavigationEnd) {
+                this.currentSession.name = document.title;
+                this.currentSession.location = document.URL;
+            }
+        });
+    }
+    getCurrentSession() {
+        return this.currentSession;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: RouteTracerService, deps: [{ token: i1.Router }, { token: 'config' }, { token: 'host' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: RouteTracerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: RouteTracerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['config']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['host']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/session-manager.service.mjs

@@ -0,0 +1,145 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, from, interval, of, tap } from 'rxjs';
+import { dateNow, detectBrowser, detectOs, getNumberOrCall, getStringOrCall, logTraceapi } from './util';
+import * as i0 from "@angular/core";
+const SLASH = '/';
+export class SessionManager {
+    constructor() {
+        this.sessionQueue = [];
+        this.sessionSendAttempts = 0;
+        this.InstanceEnvSendAttempts = 0;
+        this.sendSessionfinished = true;
+        this.sendInstanceEnvFinished = true;
+    }
+    initialize(config, host) {
+        this.logServerMain = this.sessionApiURL(host, getStringOrCall(config.sessionApi));
+        this.logInstanceEnv = this.instanceApiURL(host, getStringOrCall(config.instanceApi));
+        this.maxBufferSize = getNumberOrCall(config.bufferMaxSize) ?? 1000;
+        this.delay = getNumberOrCall(config.delay) ?? 60000;
+        this.instanceEnvironment = {
+            name: getStringOrCall(config.name),
+            version: getStringOrCall(config.version),
+            address: undefined, //server side
+            env: getStringOrCall(config.env),
+            os: detectOs(),
+            re: detectBrowser(),
+            user: undefined, // cannot get user
+            type: "CLIENT",
+            instant: dateNow(),
+            collector: "inspect-ng-collector-0.0.1"
+        };
+        this.scheduledSessionSender = interval(this.delay)
+            .pipe(tap(() => {
+            if (this.sendSessionfinished) {
+                this.sendSessions();
+            }
+        }))
+            .subscribe();
+    }
+    addSessions(sessions) {
+        this.sessionQueue.push(sessions);
+        logTraceapi('log', "added element to session queue, new size is: " + this.sessionQueue.length);
+    }
+    sendSessions() {
+        if (this.sessionQueue.length > 0) {
+            this.getInsertedInstanceId().subscribe((id) => {
+                if (id) {
+                    this.sendSessionfinished = false;
+                    let sessions = [...this.sessionQueue];
+                    this.sessionQueue.splice(0, sessions.length); // add rest of sessions
+                    logTraceapi('log', `sending sessions, attempts:${++this.sessionSendAttempts}, queue size : ${sessions.length}`);
+                    const requestOptions = {
+                        method: 'PUT',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Access-Control-Allow-Origin': '*'
+                        },
+                        body: JSON.stringify(sessions)
+                    };
+                    fetch(this.logServerMain, requestOptions)
+                        .then(data => {
+                        if (data.ok) {
+                            logTraceapi('log', 'sessions sent successfully, queue size reset, new size is: ' + this.sessionQueue.length);
+                            this.sessionSendAttempts = 0;
+                        }
+                        else {
+                            logTraceapi('warn', `Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`); //
+                            this.revertQueueSize(sessions);
+                        }
+                    })
+                        .catch(error => {
+                        logTraceapi('warn', `Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`); //
+                        logTraceapi('warn', error);
+                        this.revertQueueSize(sessions);
+                    }).finally(() => {
+                        this.sendSessionfinished = true;
+                    });
+                }
+                else {
+                    logTraceapi('warn', `Error while attempting to send Environement instance, attempts ${this.sessionSendAttempts}`);
+                }
+            });
+        }
+    }
+    revertQueueSize(sessions) {
+        this.sessionQueue.unshift(...sessions);
+        if (this.sessionQueue.length > this.maxBufferSize) {
+            let diff = this.sessionQueue.length - this.maxBufferSize;
+            this.sessionQueue = this.sessionQueue.slice(0, this.maxBufferSize);
+            logTraceapi('log', 'Buffer size exeeded the max size,last sessions have been removed from buffer, (number of sessions removed):' + diff);
+        }
+    }
+    getInsertedInstanceId() {
+        if (this.instance) {
+            return this.instance;
+        }
+        if (this.sendInstanceEnvFinished) {
+            this.sendInstanceEnvFinished = false;
+            const requestOptions = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*' // retest
+                },
+                body: JSON.stringify(this.instanceEnvironment)
+            };
+            this.sessionSendAttempts++;
+            return from(fetch(this.logInstanceEnv, requestOptions)
+                .then(res => res.ok ? res.text().then(id => {
+                this.instance = new BehaviorSubject(id);
+                this.logServerMain = this.logServerMain.replace(':id', id);
+                this.sessionSendAttempts = 0;
+                logTraceapi('log', 'Environement instance sent successfully');
+                return id; // return logserverMain
+            }) : null)
+                .catch(err => {
+                logTraceapi('warn', err);
+                return null;
+            }).finally(() => {
+                this.sendInstanceEnvFinished = true;
+            }));
+        }
+        return of(null);
+    }
+    instanceApiURL(host, path) {
+        return this.toURL(host, path);
+    }
+    sessionApiURL(host, path) {
+        return this.toURL(host, path);
+    }
+    toURL(host, path) {
+        return host.endsWith(SLASH) || path.startsWith(SLASH) ? host + path : [host, path].join(SLASH);
+    }
+    ngOnDestroy() {
+        if (this.scheduledSessionSender) {
+            this.scheduledSessionSender.unsubscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SessionManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SessionManager, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SessionManager, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session-manager.service.js","sourceRoot":"","sources":["../../../../../projects/oneteme/inspect-ng-collector/src/lib/session-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy  } from '@angular/core';\nimport { InstanceEnvironment, MainSession } from './trace.model';\nimport { BehaviorSubject, from, interval, Observable, of, Subscription, tap } from 'rxjs';\nimport { dateNow, detectBrowser, detectOs, getNumberOrCall, getStringOrCall, logTraceapi } from './util';\n\nconst SLASH = '/';\n\n@Injectable({ providedIn: 'root' })\nexport class SessionManager implements OnDestroy {\n\n    logServerMain!: string;\n    logInstanceEnv!: string;\n    maxBufferSize!: number;\n    delay!:number\n    instanceEnvironment !: InstanceEnvironment;\n    scheduledSessionSender!: Subscription;\n    sessionQueue: MainSession[]= [];\n    sessionSendAttempts: number = 0\n    InstanceEnvSendAttempts: number = 0;\n    instance!: BehaviorSubject<string>;\n    sendSessionfinished:boolean= true;\n    sendInstanceEnvFinished: boolean = true;\n    constructor(){\n\n    }\n\n\n    initialize(config:any, host:string) {\n        this.logServerMain = this.sessionApiURL(host,getStringOrCall(config.sessionApi)!);\n        this.logInstanceEnv = this.instanceApiURL(host,getStringOrCall(config.instanceApi)!);\n        this.maxBufferSize =  getNumberOrCall(config.bufferMaxSize) ?? 1000;\n        this.delay = getNumberOrCall(config.delay) ?? 60000;\n        this.instanceEnvironment = {\n            name: getStringOrCall(config.name),\n            version: getStringOrCall(config.version),\n            address: undefined, //server side\n            env: getStringOrCall(config.env),\n            os: detectOs(),\n            re: detectBrowser(),\n            user: undefined, // cannot get user\n            type: \"CLIENT\",\n            instant: dateNow(),\n            collector: \"inspect-ng-collector-0.0.1\"\n        }\n\n        this.scheduledSessionSender = interval(this.delay)\n        .pipe(tap(()=> {\n            if(this.sendSessionfinished){\n                this.sendSessions();\n            }}))\n        .subscribe();\n    }\n\n    addSessions(sessions:MainSession){\n        this.sessionQueue.push(sessions);\n        logTraceapi('log',\"added element to session queue, new size is: \"+ this.sessionQueue.length);\n    }\n\n\n    sendSessions() {\n        if(this.sessionQueue.length> 0){\n            this.getInsertedInstanceId().subscribe((id:string|null)=>{\n                if(id) {\n                    this.sendSessionfinished = false;\n                    let sessions: MainSession[] = [...this.sessionQueue];\n                    this.sessionQueue.splice(0,sessions.length); // add rest of sessions\n                    logTraceapi('log',`sending sessions, attempts:${++this.sessionSendAttempts}, queue size : ${sessions.length}`)\n\n                    const requestOptions = {\n                        method: 'PUT',\n                        headers: {\n                            'Content-Type': 'application/json',\n                            'Access-Control-Allow-Origin': '*'\n                        },\n                        body: JSON.stringify(sessions)\n                    };\n\n                    fetch(this.logServerMain, requestOptions)\n                    .then(data=> {\n                        if(data.ok){\n                            logTraceapi('log','sessions sent successfully, queue size reset, new size is: '+this.sessionQueue.length)\n                            this.sessionSendAttempts= 0;\n                        }else{\n                            logTraceapi('warn',`Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`)//\n                            this.revertQueueSize(sessions);\n                        }\n                    })\n                    .catch(error => {\n                        logTraceapi('warn',`Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`)//\n                        logTraceapi('warn',error)\n                        this.revertQueueSize(sessions);\n                    }).finally( ()=> {\n                        this.sendSessionfinished = true;\n                    })\n\n                }else {\n                    logTraceapi('warn',`Error while attempting to send Environement instance, attempts ${this.sessionSendAttempts}`);\n                }\n            })\n        }\n    }\n\n    revertQueueSize(sessions: MainSession[]){\n        this.sessionQueue.unshift(...sessions);\n        if(this.sessionQueue.length > this.maxBufferSize ){\n            let diff = this.sessionQueue.length - this.maxBufferSize;\n            this.sessionQueue = this.sessionQueue.slice(0,this.maxBufferSize);\n            logTraceapi('log','Buffer size exeeded the max size,last sessions have been removed from buffer, (number of sessions removed):'+diff)\n        }\n    }\n\n    getInsertedInstanceId() : Observable<any> {\n        if(this.instance){\n            return this.instance;\n        }\n        if(this.sendInstanceEnvFinished){\n            this.sendInstanceEnvFinished = false;\n            const requestOptions = {\n                method: 'POST',\n                headers: {\n                    'Content-Type': 'application/json',\n                    'Access-Control-Allow-Origin': '*' // retest\n                },\n                body: JSON.stringify(this.instanceEnvironment)\n            };\n            this.sessionSendAttempts++;\n            return from( fetch(this.logInstanceEnv,requestOptions)\n            .then(res => res.ok ? res.text().then(id=> {\n                this.instance = new BehaviorSubject<string>(id);\n                this.logServerMain =this.logServerMain.replace(':id',id);\n                this.sessionSendAttempts=0;\n                logTraceapi('log','Environement instance sent successfully');\n                return id; // return logserverMain\n            }) : null)\n            .catch(err => {\n                logTraceapi('warn',err)\n                return null;\n            }).finally(()=> {\n                this.sendInstanceEnvFinished = true;\n            }))\n        }\n        return of(null);\n    }\n\n    instanceApiURL(host:string, path:string){\n        return  this.toURL(host,path);\n     }\n\n     sessionApiURL(host:string, path:string){\n        return  this.toURL(host,path);\n     }\n\n     toURL( host:string,  path:string ){\n         return host.endsWith(SLASH) || path.startsWith(SLASH) ? host + path : [host,path].join(SLASH);\n     }\n\n     ngOnDestroy(): void {\n        if(this.scheduledSessionSender){\n            this.scheduledSessionSender.unsubscribe();\n        }\n    }\n}\n"]}

package/esm2022/lib/trace.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhY2UubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vbmV0ZW1lL2luc3BlY3QtbmctY29sbGVjdG9yL3NyYy9saWIvdHJhY2UubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbInR5cGUgSW5zdGFudFR5cGUgPSBcIlNFUlZFUlwiICB8IFwiQ0xJRU5UXCI7XG50eXBlIE1haW5TZXNzaW9uVHlwZSA9ICBcIlZJRVdcIiB8IFwiQkFUQ0hcIiB8IFwiU1RBUlRVUFwiO1xuZXhwb3J0IGludGVyZmFjZSBNYWluU2Vzc2lvbiB7XG4gICAgJ0B0eXBlJz86IHN0cmluZztcbiAgICB0eXBlOiBNYWluU2Vzc2lvblR5cGU7XG4gICAgbmFtZT86IHN0cmluZztcbiAgICBsb2NhdGlvbjogc3RyaW5nO1xuICAgIHVzZXI/OiBzdHJpbmc7XG4gICAgc3RhcnQ6IG51bWJlcjtcbiAgICBlbmQ/OiBudW1iZXI7XG4gICAgdGhyZWFkTmFtZT86c3RyaW5nOyAgLy8gYWx3YXlzIG51bGwgXG4gICAgZXhjZXB0aW9uPzogRXhjZXB0aW9uSW5mbyAvLyB0byBiZSBjaGFuZ2VkID8gXG4gICAgcmVzdFJlcXVlc3RzOiBSZXN0UmVxdWVzdFtdXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSW5zdGFuY2VFbnZpcm9ubWVudCB7XG4gICAgbmFtZT86IHN0cmluZztcbiAgICBhZGRyZXNzPzogc3RyaW5nO1xuICAgIHZlcnNpb24/OiBzdHJpbmc7XG4gICAgZW52Pzogc3RyaW5nO1xuICAgIG9zPzogc3RyaW5nO1xuICAgIHJlPzogc3RyaW5nO1xuICAgIHVzZXI/OiBzdHJpbmc7XG4gICAgdHlwZT86IEluc3RhbnRUeXBlO1xuICAgIGluc3RhbnQ/Om51bWJlcjsgICBcbiAgICBjb2xsZWN0b3I/OnN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZXN0UmVxdWVzdCB7XG4gICAgaWQ/OiBzdHJpbmc7XG4gICAgbWV0aG9kOiBzdHJpbmc7XG4gICAgcHJvdG9jb2w6IHN0cmluZztcbiAgICBob3N0OiBzdHJpbmc7XG4gICAgcG9ydDogbnVtYmVyO1xuICAgIHBhdGg6IHN0cmluZztcbiAgICBxdWVyeTogc3RyaW5nO1xuICAgIGNvbnRlbnRUeXBlOiBzdHJpbmc7XG4gICAgYXV0aFNjaGVtZT86IHN0cmluZztcbiAgICBzdGF0dXM6IG51bWJlcjtcbiAgICBpbkRhdGFTaXplOiBudW1iZXI7XG4gICAgb3VEYXRhU2l6ZTogbnVtYmVyO1xuICAgIHVzZXI/OnN0cmluZztcbiAgICBzdGFydDogbnVtYmVyO1xuICAgIGVuZDogbnVtYmVyO1xuICAgIHRocmVhZE5hbWU/OnN0cmluZztcbiAgICBleGNlcHRpb24/OiBFeGNlcHRpb25JbmZvXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRXhjZXB0aW9uSW5mbyB7IC8vIHRvIGJlY2hhbmdlZCBcbiAgICB0eXBlOiBzdHJpbmc7XG4gICAgbWVzc2FnZTogc3RyaW5nO1xufVxuXG4iXX0=

package/esm2022/lib/util.mjs

@@ -0,0 +1,131 @@
+let WIN = window;
+let c = console;
+export const HOST_PATERN = /https?:\/\/[\w\-\.]+(:\d{2,5})?\/?/;
+export const PATH_PATERN = /[\w\-\{\}]+(\/[\w\-\{\}]+)*/;
+export function dateNow() {
+    return Date.now() / 1000;
+}
+export function logTraceapi(fn, ...args) {
+    if (WIN["traceapi"]) {
+        if (typeof c[fn] === 'function') {
+            c[fn]('[TRACEAPI]', ...args);
+        }
+    }
+}
+export function prettySessionFormat(session) {
+    let s = "";
+    if (WIN['debug']) {
+        s = `[${session.name}]`;
+        if (session.user != null) {
+            s += `<${session.user}>`;
+        }
+        if (session.location) {
+            s += `(${session.location}) `;
+        }
+        s += prettyDurationFormat(session.start, session.end);
+        session.restRequests.forEach(r => {
+            s += prettyRestRequestFormat(r);
+        });
+    }
+    return s;
+}
+function prettyRestRequestFormat(rest) {
+    let s = `  -  [${rest.method}]`;
+    if (rest.protocol) {
+        s += `${rest.protocol}://`;
+    }
+    if (rest.host) {
+        s += rest.host;
+    }
+    if (rest.port > 0) {
+        s += `:${rest.port}`;
+    }
+    if (rest.path) {
+        if (!rest.path.startsWith("/") && !s.endsWith("/")) {
+            s += '/';
+        }
+        s += rest.path;
+    }
+    if (rest.query) {
+        s += rest.query;
+    }
+    if (rest.exception?.type) {
+        s += ` ${rest.exception?.type}:`;
+    }
+    if (rest.exception?.message) {
+        s += ` ${rest.exception.message}`;
+    }
+    s += ` >> ${rest.status}`;
+    s += prettyDurationFormat(rest.start, rest.end);
+    return s;
+}
+function prettyDurationFormat(start, end) {
+    return start && end ? `(in ${new Date(end * 1000).getTime() - new Date(start * 1000).getTime()} ms) \n` : '';
+}
+export function validate(v, pattern) {
+    if (v && pattern.exec(v)) {
+        return true;
+    }
+    logTraceapi('warn', "bad value=" + v + ", pattern=" + pattern);
+    return false;
+}
+export function requirePostitiveValue(v, name) {
+    if (v == undefined || (v && v > 0)) {
+        return true;
+    }
+    logTraceapi('warn', name + '=' + v + " <= 0");
+    return false;
+}
+export function getNumberOrCall(o) {
+    return typeof o === "function" ? o() : o;
+}
+export function getStringOrCall(o) {
+    return typeof o === "function" ? o() : o;
+}
+export function getRegArrOrCall(o) {
+    return typeof o === "function" ? o() : o;
+}
+export function detectBrowser() {
+    try {
+        const agent = window.navigator.userAgent.toLowerCase();
+        switch (true) {
+            case agent.indexOf('edge') > -1:
+                return 'edge';
+            case agent.indexOf('opr') > -1:
+                return 'opera';
+            case agent.indexOf('chrome') > -1:
+                return 'chrome';
+            case agent.indexOf('firefox') > -1:
+                return 'firefox';
+            case agent.indexOf('safari') > -1:
+                return 'safari';
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return undefined;
+}
+export function detectOs() {
+    try {
+        let versionMatch, version;
+        const agent = window.navigator.userAgent.toLowerCase();
+        switch (true) {
+            case (/windows/.test(agent)):
+                versionMatch = /windows nt (\d+\.\d+)/.exec(agent);
+                version = versionMatch ? versionMatch[1] : 'Unknown';
+                return `Windows ${version}`;
+            case (/linux/.test(agent)):
+                return 'Linux';
+            case (/macintosh/.test(agent)):
+                versionMatch = /mac os x (\d+[._]\d+[._]\d+)/.exec(agent);
+                version = versionMatch ? versionMatch[1] : 'Unknown';
+                return `MacOs ${version}`;
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../projects/oneteme/inspect-ng-collector/src/lib/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { MainSession, RestRequest } from \"./trace.model\";\n\nlet WIN:any = window;\nlet c:any = console;\n\nexport const HOST_PATERN = /https?:\\/\\/[\\w\\-\\.]+(:\\d{2,5})?\\/?/;\nexport const PATH_PATERN = /[\\w\\-\\{\\}]+(\\/[\\w\\-\\{\\}]+)*/;\n\nexport function dateNow() {\n    return Date.now() / 1_000;\n}\n\nexport function logTraceapi(fn:string ,...args: any[]){\n\n  if(WIN[\"traceapi\"]){\n      if( typeof c[fn] === 'function'){\n        c[fn]('[TRACEAPI]', ...args)\n      }\n    }\n}\n\nexport function prettySessionFormat(session: MainSession){\n  let s=\"\";\n  if(WIN['debug']){\n     s  = `[${session.name}]`;\n    if(session.user != null){\n      s+= `<${session.user}>`\n    }\n    if(session.location){\n      s+= `(${session.location}) `\n    }\n    s+=prettyDurationFormat(session.start,session.end!);\n    session.restRequests.forEach(r => {\n      s+= prettyRestRequestFormat(r);\n    })\n  }\n  return s;\n}\n\nfunction prettyRestRequestFormat(rest: RestRequest){\n  let s = `  -  [${rest.method}]`\n  if(rest.protocol){\n    s+= `${rest.protocol}://`\n  }\n\n  if(rest.host){\n    s+= rest.host\n  }\n\n  if(rest.port > 0){\n    s+= `:${rest.port}`\n  }\n\n  if(rest.path){\n    if(!rest.path.startsWith(\"/\") && !s.endsWith(\"/\")){\n      s+= '/'\n    }\n    s+= rest.path;\n  }\n\n  if(rest.query){\n    s+= rest.query\n  }\n\n  if(rest.exception?.type){\n    s+= ` ${rest.exception?.type}:`;\n  }\n\n  if(rest.exception?.message){\n    s+= ` ${rest.exception.message}`;\n  }\n  s+= ` >> ${rest.status}`\n  s+= prettyDurationFormat(rest.start,rest.end);\n  return s;\n}\n\nfunction prettyDurationFormat(start:number,end:number){\n    return  start && end ? `(in ${ new Date(end*1000).getTime()- new Date(start*1000).getTime() } ms) \\n` : '';\n}\n\n\n\nexport function validate(v: string | undefined, pattern: RegExp) {\n   if(v && pattern.exec(v)){\n      return true;\n   }\n\n\n   logTraceapi('warn',\"bad value=\" + v + \", pattern=\" + pattern);\n   return false;\n}\n\nexport function requirePostitiveValue(v: number | undefined, name: string){\n  if(v == undefined ||  (v && v > 0)) {\n    return true;\n  }\n\n  logTraceapi('warn',name +'='+ v + \" <= 0\");\n  return false;\n}\n\nexport function getNumberOrCall(o?: number | (() => number)): number | undefined {\n  return typeof o === \"function\" ? o() : o;\n}\n\nexport function getStringOrCall(o?: string | (() => string)): string | undefined {\n  return typeof o === \"function\" ? o() : o;\n}\n\nexport function getRegArrOrCall(o?: RegExp[] | (() => RegExp[])): RegExp[] | undefined {\n  return typeof o === \"function\" ? o() : o;\n}\n\nexport function detectBrowser() {\n  try {\n      const agent = window.navigator.userAgent.toLowerCase()\n      switch (true) {\n          case agent.indexOf('edge') > -1:\n              return 'edge';\n          case agent.indexOf('opr') > -1:\n              return 'opera';\n          case agent.indexOf('chrome') > -1:\n              return 'chrome';\n          case agent.indexOf('firefox') > -1:\n              return 'firefox';\n          case agent.indexOf('safari') > -1:\n              return 'safari';\n      }\n  }\n  catch (e) {\n      console.error(e);\n  }\n  return undefined;\n\n}\n\nexport function detectOs() {\n  try {\n      let versionMatch, version;\n      const agent = window.navigator.userAgent.toLowerCase()\n      switch (true) {\n          case (/windows/.test(agent)):\n\n              versionMatch = /windows nt (\\d+\\.\\d+)/.exec(agent);\n              version = versionMatch ? versionMatch[1] : 'Unknown';\n              return `Windows ${version}`;\n          case (/linux/.test(agent)):\n              return 'Linux';\n\n          case (/macintosh/.test(agent)):\n              versionMatch = /mac os x (\\d+[._]\\d+[._]\\d+)/.exec(agent);\n              version = versionMatch ? versionMatch[1] : 'Unknown';\n              return `MacOs ${version}`\n      }\n  }\n  catch (e) {\n      console.error(e);\n  }\n  return undefined;\n}\n"]}

package/esm2022/oneteme-inspect-ng-collector.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25ldGVtZS1pbnNwZWN0LW5nLWNvbGxlY3Rvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL29uZXRlbWUvaW5zcGVjdC1uZy1jb2xsZWN0b3Ivc3JjL29uZXRlbWUtaW5zcGVjdC1uZy1jb2xsZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of inspect-ng-collector
+ */
+export * from './lib/ng-collector.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL29uZXRlbWUvaW5zcGVjdC1uZy1jb2xsZWN0b3Ivc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFHSCxjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBpbnNwZWN0LW5nLWNvbGxlY3RvclxuICovXG5cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvbmctY29sbGVjdG9yLm1vZHVsZSc7XG5cbiAiXX0=