@oneteme/inspect-ng-collector 0.0.6 → 0.0.8

package/esm2022/lib/configuration.mjs

@@ -0,0 +1,145 @@
+import { dateNow } from "./util";
+const SLASH = '/';
+const HOST_PATERN = /https?:\/\/[\w\-.]+(:\d{2,5})?\/?/;
+const PATH_PATERN = /[\w-]+(\/[\w-]+)*/;
+const validationMap = {
+    host: { func: matchRegex, args: [HOST_PATERN] },
+    bufferMaxSize: { func: requirePostitiveValue, args: [HOST_PATERN] },
+    delay: { func: matchRegex, args: [HOST_PATERN] },
+    instanceApi: { func: matchRegex, args: [HOST_PATERN] },
+    sessionApi: { func: matchRegex, args: [HOST_PATERN] }
+};
+export function setConfig(conf) {
+    return {
+        host: conf.host,
+        name: getStringOrCall(conf.name),
+        version: getStringOrCall(conf.version) ?? '',
+        env: getStringOrCall(conf.env) ?? '',
+        user: getStringOrCall(conf.user) ?? '',
+        bufferMaxSize: getNumberOrCall(conf.bufferMaxSize),
+        delay: getNumberOrCall(conf.delay),
+        instanceApi: getStringOrCall(conf.sessionApi),
+        sessionApi: getStringOrCall(conf.instanceApi),
+        exclude: getRegArrOrCall(conf.exclude) ?? [],
+        debug: conf.debug ?? false,
+        enabled: conf.enabled ?? false
+    };
+    /*
+     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;
+     */
+}
+export function validateProperty(value, func) {
+    if (func()) {
+        return value;
+    }
+    throw new Error('error'); // pass the error return from the the passed function 
+}
+export function validateAndGetConfig(conf) {
+    let host = matchRegex(getStringOrCall(conf.host), "host", HOST_PATERN);
+    let sessionApi = matchRegex(getStringOrCall(conf.sessionApi), 'sessionApi', PATH_PATERN);
+    let instanceApi = matchRegex(getStringOrCall(conf.sessionApi), 'intanceApi', PATH_PATERN);
+    return {
+        user: getStringOrCall(conf.user),
+        bufferMaxSize: requirePostitiveValue(getNumberOrCall(conf.delay), "bufferMaxSize", 1000),
+        delay: requirePostitiveValue(getNumberOrCall(conf.delay), "delay", 60000),
+        instanceApi: sessionApiURL(host, sessionApi),
+        sessionApi: instanceApiURL(host, instanceApi),
+        exclude: getRegArrOrCall(conf.exclude) || [],
+        debug: conf.debug ?? false,
+        enabled: conf.enabled ?? false
+    };
+}
+export function GetInstanceEnvironement(conf) {
+    return {
+        name: getStringOrCall(conf.name),
+        version: getStringOrCall(conf.version),
+        address: undefined,
+        env: getStringOrCall(conf.env),
+        os: detectOs(),
+        re: detectBrowser(),
+        user: undefined,
+        type: "CLIENT",
+        instant: dateNow(),
+        collector: "inspect-ng-collector-0.0.1"
+    };
+}
+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;
+}
+function instanceApiURL(host, path) {
+    return toURL(host, path);
+}
+function sessionApiURL(host, path) {
+    return toURL(host, path);
+}
+function toURL(host, path) {
+    return host.endsWith(SLASH) || path.startsWith(SLASH) ? host + path : [host, path].join(SLASH);
+}
+export function matchRegex(v, name, pattern) {
+    if (v && pattern.exec(v)) {
+        return v;
+    }
+    throw `bad value ${name}=${v}, pattern=${pattern}`;
+}
+export function requirePostitiveValue(v, name, defaultValue) {
+    if (v && v > 0) {
+        return v;
+    }
+    if (v == undefined) {
+        return defaultValue;
+    }
+    throw `bad value ${name}= ${v} <= 0`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../../../../projects/oneteme/inspect-ng-collector/src/lib/configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import { dateNow } from \"./util\";\nconst SLASH = '/';\nconst HOST_PATERN = /https?:\\/\\/[\\w\\-.]+(:\\d{2,5})?\\/?/;\nconst PATH_PATERN = /[\\w-]+(\\/[\\w-]+)*/;\nexport interface ApplicationConf {\n  host?: string;\n  name?: string | (() => string);\n  version?: string | (() => string);\n  env?: string | (() => string);\n  user?: string | (() => string);\n  bufferMaxSize?: number | (() => number);\n  delay?: number| (() => number);\n  instanceApi?: string | (() => string);\n  sessionApi?: string | (() => string);\n  exclude?: RegExp[] | (() => RegExp[]);\n  debug?: boolean;\n  enabled?: boolean;\n}\n\nexport interface TechnicalConf {\n  user?:string ;\n  bufferMaxSize: number;\n  delay: number;\n  instanceApi: string;\n  sessionApi: string;\n  exclude: RegExp[];\n  debug: boolean;\n  enabled: boolean;\n}\n\n const validationMap  = { // remove \n  host: { func: matchRegex, args: [HOST_PATERN] },\n  bufferMaxSize:  { func: requirePostitiveValue, args: [HOST_PATERN] },\n  delay:  { func: matchRegex, args: [HOST_PATERN] },\n  instanceApi:  { func: matchRegex, args: [HOST_PATERN] },\n  sessionApi:  { func: matchRegex, args: [HOST_PATERN] }\n }\n\nexport function setConfig(conf:ApplicationConf){\n  return  {\n    host: conf.host,\n    name: getStringOrCall(conf.name),\n    version: getStringOrCall(conf.version) ?? '',\n    env: getStringOrCall(conf.env)?? '',\n    user: getStringOrCall(conf.user) ?? '',\n    bufferMaxSize: getNumberOrCall(conf.bufferMaxSize),\n    delay: getNumberOrCall(conf.delay),\n    instanceApi: getStringOrCall(conf.sessionApi),\n    sessionApi: getStringOrCall(conf.instanceApi),\n    exclude: getRegArrOrCall(conf.exclude) ?? [], \n    debug: conf.debug ?? false,\n    enabled: conf.enabled ?? false\n  }\n /*\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  */\n} \n\nexport function validateProperty(value:any, func : (...args:any)=> boolean){\n  if(func()){\n      return value;\n  }\n  throw new Error('error') // pass the error return from the the passed function \n}\n\n\n\nexport function validateAndGetConfig(conf:any):TechnicalConf{\n  let host = matchRegex(getStringOrCall(conf.host), \"host\" , HOST_PATERN) \n  let sessionApi =   matchRegex(getStringOrCall(conf.sessionApi),'sessionApi', PATH_PATERN,) \n  let instanceApi =  matchRegex(getStringOrCall(conf.sessionApi),'intanceApi', PATH_PATERN,)\n  return  {\n    user : getStringOrCall(conf.user),\n    bufferMaxSize:  requirePostitiveValue(getNumberOrCall(conf.delay),\"bufferMaxSize\", 1000) ,\n    delay: requirePostitiveValue(getNumberOrCall(conf.delay),\"delay\", 60000) ,\n    instanceApi: sessionApiURL(host, sessionApi),\n    sessionApi: instanceApiURL(host, instanceApi),\n    exclude: getRegArrOrCall(conf.exclude) || [],\n    debug: conf.debug ?? false,\n    enabled: conf.enabled ?? false\n  }\n}\n\nexport function GetInstanceEnvironement(conf:ApplicationConf){\n    return {\n      name: getStringOrCall(conf.name),\n      version: getStringOrCall(conf.version),\n      address: undefined, //server side\n      env: getStringOrCall(conf.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\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\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              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\nfunction instanceApiURL(host:string, path:string){\n  return  toURL(host,path);\n}\n\nfunction sessionApiURL(host:string, path:string){\n  return  toURL(host,path);\n}\n\nfunction toURL(host:string, path:string ){\n   return host.endsWith(SLASH) || path.startsWith(SLASH) ? host + path : [host,path].join(SLASH);\n}\n\nexport function matchRegex(v: string | undefined,  name: string, pattern: RegExp,) {\n  if(v && pattern.exec(v)){\n     return v;\n  }\n  throw `bad value ${name}=${v}, pattern=${pattern}`;\n}\n\nexport function requirePostitiveValue(v: number | undefined, name: string, defaultValue:number){\n  if(v && v > 0) {\n    return v;\n  }\n  if(v == undefined){\n    return defaultValue;\n  }\n  throw `bad value ${name}= ${v} <= 0`  \n}\n\n"]}

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

@@ -0,0 +1,33 @@
+import { Injectable } from "@angular/core";
+import { NavigationEnd, NavigationStart } from "@angular/router";
+import { logInspect } from "./util";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./session-manager.service";
+export class EventManagerService {
+    constructor(router, sessionManager) {
+        this.router = router;
+        this.sessionManager = sessionManager;
+        logInspect('initialize EventManagerService');
+        window.addEventListener('beforeunload', (event) => {
+            this.sessionManager.newSession(); //force 
+            this.sessionManager.sendSessions();
+        });
+        this.router.events.subscribe(event => {
+            if (event instanceof NavigationStart) {
+                this.sessionManager.newSession(event.url);
+            }
+            if (event instanceof NavigationEnd) {
+                this.sessionManager.getCurrentSession().name = document.title;
+                this.sessionManager.getCurrentSession().location = document.URL;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EventManagerService, deps: [{ token: i1.Router }, { token: i2.SessionManager }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EventManagerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EventManagerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.SessionManager }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,11 +3,11 @@ 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";
+import * as i1 from "./session-manager.service";
 export class HttpInterceptorService {
-    constructor(routerTracerService) {
-        this.routerTracerService = routerTracerService;
-    }
+    constructor(SessionManager) {
+        this.SessionManager = SessionManager;
+    } // change this to session manager
     intercept(req, next) {
         const start = dateNow();
         let status, responseBody = '', exception;
@@ -19,7 +19,6 @@ export class HttpInterceptorService {
                 id = getReqid(event.headers);
             }
         }, error => {
-            console.log(error);
             id = getReqid(error.headers);
             status = +error.status;
             exception = {
@@ -28,7 +27,7 @@ export class HttpInterceptorService {
             };
         }), finalize(() => {
             const url = toHref(req.urlWithParams);
-            this.routerTracerService.getCurrentSession().restRequests.push({
+            this.SessionManager.getCurrentSession().restRequests.push({
                 id: id,
                 method: req.method,
                 protocol: url.protocol.slice(0, -1),
@@ -47,13 +46,13 @@ export class HttpInterceptorService {
             });
         }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpInterceptorService, deps: [{ token: i1.RouteTracerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpInterceptorService, deps: [{ token: i1.SessionManager }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpInterceptorService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpInterceptorService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i1.RouteTracerService }]; } });
+        }], ctorParameters: function () { return [{ type: i1.SessionManager }]; } });
 function toHref(url) {
     const href = document.createElement('a');
     href.setAttribute('href', url);
@@ -76,4 +75,4 @@ function getReqid(headers) {
 function sizeOf(body) {
     return body ? JSON.stringify(body).length : 0;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC1pbnRlcmNlcHRvci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvb25ldGVtZS9pbnNwZWN0LW5nLWNvbGxlY3Rvci9zcmMvbGliL2h0dHAtaW50ZXJjZXB0b3Iuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBd0QsWUFBWSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDMUcsT0FBTyxFQUFFLEdBQUcsRUFBRSxRQUFRLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQTtBQUU5QyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sUUFBUSxDQUFDOzs7QUFJakMsTUFBTSxPQUFPLHNCQUFzQjtJQUUvQixZQUFvQixjQUE4QjtRQUE5QixtQkFBYyxHQUFkLGNBQWMsQ0FBZ0I7SUFBSSxDQUFDLENBQUMsaUNBQWlDO0lBRXpGLFNBQVMsQ0FBQyxHQUFxQixFQUFFLElBQWlCO1FBQzlDLE1BQU0sS0FBSyxHQUFHLE9BQU8sRUFBRSxDQUFDO1FBQ3hCLElBQUksTUFBYyxFQUFFLFlBQVksR0FBUSxFQUFFLEVBQUUsU0FBd0IsQ0FBQztRQUNyRSxJQUFJLEVBQXFCLENBQUM7UUFDMUIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQzVCLENBQUMsS0FBVSxFQUFFLEVBQUU7WUFDWCxJQUFJLEtBQUssWUFBWSxZQUFZLEVBQUU7Z0JBQy9CLE1BQU0sR0FBRyxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUM7Z0JBQ3ZCLFlBQVksR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFBO2dCQUN6QixFQUFFLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQzthQUNoQztRQUNMLENBQUMsRUFDRCxLQUFLLENBQUMsRUFBRTtZQUNKLEVBQUUsR0FBRyxRQUFRLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1lBQzdCLE1BQU0sR0FBRyxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDdkIsU0FBUyxHQUFHO2dCQUNSLElBQUksRUFBRSxLQUFLLENBQUMsS0FBSyxDQUFDLEtBQUs7Z0JBQ3ZCLE9BQU8sRUFBRSxLQUFLLENBQUMsS0FBSyxDQUFDLE9BQU87YUFDL0IsQ0FBQTtRQUNMLENBQUMsQ0FDSixFQUFFLFFBQVEsQ0FBQyxHQUFHLEVBQUU7WUFFYixNQUFNLEdBQUcsR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1lBQ3RDLElBQUksQ0FBQyxjQUFjLENBQUMsaUJBQWlCLEVBQUUsQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDO2dCQUN0RCxFQUFFLEVBQUUsRUFBRTtnQkFDTixNQUFNLEVBQUUsR0FBRyxDQUFDLE1BQU07Z0JBQ2xCLFFBQVEsRUFBRSxHQUFHLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7Z0JBQ25DLElBQUksRUFBRSxZQUFZLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQztnQkFDNUIsSUFBSSxFQUFFLENBQUMsR0FBRyxDQUFDLElBQUk7Z0JBQ2YsSUFBSSxFQUFFLEdBQUcsQ0FBQyxRQUFRO2dCQUNsQixLQUFLLEVBQUUsR0FBRyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDO2dCQUM3QyxXQUFXLEVBQUUsR0FBRyxDQUFDLFlBQVk7Z0JBQzdCLFVBQVUsRUFBRSxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDO2dCQUMxQyxNQUFNLEVBQUUsQ0FBQyxNQUFNO2dCQUNmLFVBQVUsRUFBRSxNQUFNLENBQUMsWUFBWSxDQUFDO2dCQUNoQyxVQUFVLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUM7Z0JBQzVCLEtBQUssRUFBRSxLQUFLO2dCQUNaLEdBQUcsRUFBRSxPQUFPLEVBQUU7Z0JBQ2QsU0FBUyxFQUFFLFNBQVM7YUFDdkIsQ0FBQyxDQUFDO1FBQ1AsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNSLENBQUM7K0dBN0NRLHNCQUFzQjttSEFBdEIsc0JBQXNCLGNBRFQsTUFBTTs7NEZBQ25CLHNCQUFzQjtrQkFEbEMsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUU7O0FBaURsQyxTQUFTLE1BQU0sQ0FBQyxHQUFXO0lBQ3ZCLE1BQU0sSUFBSSxHQUFHLFFBQVEsQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDekMsSUFBSSxDQUFDLFlBQVksQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDL0IsT0FBTyxJQUFJLENBQUM7QUFDaEIsQ0FBQztBQUVELFNBQVMsWUFBWSxDQUFDLElBQVk7SUFDOUIsTUFBTSxTQUFTLEdBQUcsTUFBTSxDQUFDO0lBQ3pCLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLEVBQUUsRUFBRSxDQUFDLENBQUE7QUFDdEMsQ0FBQztBQUVELFNBQVMsaUJBQWlCLENBQUMsT0FBWTtJQUNuQyxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDO1FBQy9CLENBQUMsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ3RELENBQUMsQ0FBQyxTQUFTLENBQUM7QUFDcEIsQ0FBQztBQUVELFNBQVMsUUFBUSxDQUFDLE9BQVc7SUFDekIsT0FBTyxPQUFPLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBQztRQUMzQixDQUFDLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxXQUFXLENBQUM7UUFDMUIsQ0FBQyxDQUFDLFNBQVMsQ0FBQztBQUNwQixDQUFDO0FBRUQsU0FBUyxNQUFNLENBQUMsSUFBUztJQUNyQixPQUFPLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNsRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgSHR0cEludGVyY2VwdG9yLCBIdHRwRXZlbnQsIEh0dHBIYW5kbGVyLCBIdHRwUmVxdWVzdCwgSHR0cFJlc3BvbnNlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHsgdGFwLCBmaW5hbGl6ZSB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJ1xuaW1wb3J0IHsgRXhjZXB0aW9uSW5mbyB9IGZyb20gJy4vdHJhY2UubW9kZWwnO1xuaW1wb3J0IHsgZGF0ZU5vdyB9IGZyb20gJy4vdXRpbCc7XG5pbXBvcnQgeyBTZXNzaW9uTWFuYWdlciB9IGZyb20gJy4vc2Vzc2lvbi1tYW5hZ2VyLnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIEh0dHBJbnRlcmNlcHRvclNlcnZpY2UgaW1wbGVtZW50cyBIdHRwSW50ZXJjZXB0b3Ige1xuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBTZXNzaW9uTWFuYWdlcjogU2Vzc2lvbk1hbmFnZXIpIHsgfSAvLyBjaGFuZ2UgdGhpcyB0byBzZXNzaW9uIG1hbmFnZXJcblxuICAgIGludGVyY2VwdChyZXE6IEh0dHBSZXF1ZXN0PGFueT4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8YW55Pj4ge1xuICAgICAgICBjb25zdCBzdGFydCA9IGRhdGVOb3coKTtcbiAgICAgICAgbGV0IHN0YXR1czogbnVtYmVyLCByZXNwb25zZUJvZHk6IGFueSA9ICcnLCBleGNlcHRpb246IEV4Y2VwdGlvbkluZm87XG4gICAgICAgIGxldCBpZDogc3RyaW5nfCB1bmRlZmluZWQ7XG4gICAgICAgIHJldHVybiBuZXh0LmhhbmRsZShyZXEpLnBpcGUodGFwKFxuICAgICAgICAgICAgKGV2ZW50OiBhbnkpID0+IHtcbiAgICAgICAgICAgICAgICBpZiAoZXZlbnQgaW5zdGFuY2VvZiBIdHRwUmVzcG9uc2UpIHtcbiAgICAgICAgICAgICAgICAgICAgc3RhdHVzID0gK2V2ZW50LnN0YXR1cztcbiAgICAgICAgICAgICAgICAgICAgcmVzcG9uc2VCb2R5ID0gZXZlbnQuYm9keVxuICAgICAgICAgICAgICAgICAgICBpZCA9IGdldFJlcWlkKGV2ZW50LmhlYWRlcnMpO1xuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgICBlcnJvciA9PiB7XG4gICAgICAgICAgICAgICAgaWQgPSBnZXRSZXFpZChlcnJvci5oZWFkZXJzKTtcbiAgICAgICAgICAgICAgICBzdGF0dXMgPSArZXJyb3Iuc3RhdHVzO1xuICAgICAgICAgICAgICAgIGV4Y2VwdGlvbiA9IHtcbiAgICAgICAgICAgICAgICAgICAgdHlwZTogZXJyb3IuZXJyb3IuZXJyb3IsXG4gICAgICAgICAgICAgICAgICAgIG1lc3NhZ2U6IGVycm9yLmVycm9yLm1lc3NhZ2VcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICB9LFxuICAgICAgICApLCBmaW5hbGl6ZSgoKSA9PiB7XG5cbiAgICAgICAgICAgIGNvbnN0IHVybCA9IHRvSHJlZihyZXEudXJsV2l0aFBhcmFtcyk7XG4gICAgICAgICAgICB0aGlzLlNlc3Npb25NYW5hZ2VyLmdldEN1cnJlbnRTZXNzaW9uKCkucmVzdFJlcXVlc3RzLnB1c2goe1xuICAgICAgICAgICAgICAgIGlkOiBpZCxcbiAgICAgICAgICAgICAgICBtZXRob2Q6IHJlcS5tZXRob2QsXG4gICAgICAgICAgICAgICAgcHJvdG9jb2w6IHVybC5wcm90b2NvbC5zbGljZSgwLCAtMSksXG4gICAgICAgICAgICAgICAgaG9zdDogZXhjdHJhY3RIb3N0KHVybC5ob3N0KSxcbiAgICAgICAgICAgICAgICBwb3J0OiArdXJsLnBvcnQsXG4gICAgICAgICAgICAgICAgcGF0aDogdXJsLnBhdGhuYW1lLFxuICAgICAgICAgICAgICAgIHF1ZXJ5OiB1cmwuc2VhcmNoLnNsaWNlKDEsIHVybC5zZWFyY2gubGVuZ3RoKSxcbiAgICAgICAgICAgICAgICBjb250ZW50VHlwZTogcmVxLnJlc3BvbnNlVHlwZSxcbiAgICAgICAgICAgICAgICBhdXRoU2NoZW1lOiBleHRyYWN0QXV0aFNjaGVtZShyZXEuaGVhZGVycyksXG4gICAgICAgICAgICAgICAgc3RhdHVzOiArc3RhdHVzLFxuICAgICAgICAgICAgICAgIGluRGF0YVNpemU6IHNpemVPZihyZXNwb25zZUJvZHkpLFxuICAgICAgICAgICAgICAgIG91RGF0YVNpemU6IHNpemVPZihyZXEuYm9keSksXG4gICAgICAgICAgICAgICAgc3RhcnQ6IHN0YXJ0LFxuICAgICAgICAgICAgICAgIGVuZDogZGF0ZU5vdygpLFxuICAgICAgICAgICAgICAgIGV4Y2VwdGlvbjogZXhjZXB0aW9uXG4gICAgICAgICAgICB9KTtcbiAgICAgICAgfSkpO1xuICAgIH1cbn1cblxuZnVuY3Rpb24gdG9IcmVmKHVybDogc3RyaW5nKTogSFRNTEFuY2hvckVsZW1lbnQge1xuICAgIGNvbnN0IGhyZWYgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdhJyk7XG4gICAgaHJlZi5zZXRBdHRyaWJ1dGUoJ2hyZWYnLCB1cmwpO1xuICAgIHJldHVybiBocmVmO1xufVxuXG5mdW5jdGlvbiBleGN0cmFjdEhvc3QocGF0aDogc3RyaW5nKSB7XG4gICAgY29uc3QgcG9ydHJlZ2V4ID0gLzpcXGQrLztcbiAgICByZXR1cm4gcGF0aC5yZXBsYWNlKHBvcnRyZWdleCwgJycpXG59XG5cbmZ1bmN0aW9uIGV4dHJhY3RBdXRoU2NoZW1lKGhlYWRlcnM6IGFueSk6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gICAgcmV0dXJuIGhlYWRlcnMuaGFzKCdhdXRob3JpemF0aW9uJylcbiAgICAgICAgPyBoZWFkZXJzLmdldCgnYXV0aG9yaXphdGlvbicpLm1hdGNoKC9eKFxcdyspIC8pPy5hdCgxKVxuICAgICAgICA6IHVuZGVmaW5lZDtcbn1cblxuZnVuY3Rpb24gZ2V0UmVxaWQoaGVhZGVyczphbnkpOnN0cmluZyB8IHVuZGVmaW5lZCB7XG4gICAgcmV0dXJuIGhlYWRlcnMuaGFzKCd4LXRyYWNlcnQnKVxuICAgICAgICA/IGhlYWRlcnMuZ2V0KCd4LXRyYWNlcnQnKVxuICAgICAgICA6IHVuZGVmaW5lZDtcbn1cblxuZnVuY3Rpb24gc2l6ZU9mKGJvZHk6IGFueSk6IG51bWJlciB7XG4gICAgcmV0dXJuIGJvZHkgPyBKU09OLnN0cmluZ2lmeShib2R5KS5sZW5ndGggOiAwO1xufVxuIl19

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

@@ -1,32 +1,32 @@
 import { NgModule, APP_INITIALIZER } from '@angular/core';
 import { HTTP_INTERCEPTORS, } from '@angular/common/http';
+import { logInspect } from './util';
+import { NavigationEnd, NavigationStart, Router } from '@angular/router';
+import { GetInstanceEnvironement, validateAndGetConfig } from './configuration';
 import { HttpInterceptorService } from './http-interceptor.service';
-import { RouteTracerService } from './route-tracer.service';
-import { getNumberOrCall, requirePostitiveValue, matchRegex, 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
-            && matchRegex(host, HOST_PATERN)
-            && matchRegex(getStringOrCall(configuration?.sessionApi), PATH_PATERN)
-            && matchRegex(getStringOrCall(configuration?.instanceApi), PATH_PATERN)) {
-            if (!requirePostitiveValue(getNumberOrCall(configuration?.delay), "delay") ||
-                !requirePostitiveValue(getNumberOrCall(configuration?.bufferMaxSize), "bufferMaxSize")) {
-                console.warn('invalid Configuration, Ng-collector is disabled');
-                return { ngModule: NgCollectorModule };
+    static forRoot(configuration) {
+        if (configuration?.enabled) {
+            try {
+                let config = validateAndGetConfig(configuration);
+                let instance = GetInstanceEnvironement(configuration);
+                return {
+                    ngModule: NgCollectorModule,
+                    providers: [
+                        SessionManager,
+                        //EventManagerService,
+                        { provide: APP_INITIALIZER, useFactory: initializeEvents, deps: [Router, SessionManager], multi: true },
+                        { provide: HTTP_INTERCEPTORS, useClass: HttpInterceptorService, multi: true },
+                        { provide: 'instance', useValue: instance },
+                        { provide: 'config', useValue: config }
+                    ]
+                };
+            }
+            catch (e) {
+                console.warn('invalid Configuration, Ng-collector is disabled because', e);
             }
-            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
@@ -37,10 +37,24 @@ export class NgCollectorModule {
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgCollectorModule }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgCollectorModule, decorators: [{
-            type: NgModule,
-            args: [{}]
+            type: NgModule
         }] });
-export function initializeRoutingEvents(routeTracerService) {
-    return () => routeTracerService.initialize();
+export function initializeEvents(router, sessionManager) {
+    return () => {
+        logInspect('initialize routing events listeners');
+        window.addEventListener('beforeunload', (event) => {
+            sessionManager.newSession(); //force 
+            sessionManager.sendSessions();
+        });
+        router.events.subscribe(event => {
+            if (event instanceof NavigationStart) {
+                sessionManager.newSession(event.url);
+            }
+            if (event instanceof NavigationEnd) {
+                sessionManager.getCurrentSession().name = document.title;
+                sessionManager.getCurrentSession().location = document.URL;
+            }
+        });
+    };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,33 +1,16 @@
-import { Injectable } from '@angular/core';
+import { Inject, Injectable } from '@angular/core';
 import { BehaviorSubject, from, interval, of, tap } from 'rxjs';
-import { dateNow, detectBrowser, detectOs, getNumberOrCall, getStringOrCall, logInspect } from './util';
+import { dateNow, logInspect, prettySessionFormat } from './util';
 import * as i0 from "@angular/core";
-const SLASH = '/';
 export class SessionManager {
-    constructor() {
+    constructor(config, instance) {
         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,
-            env: getStringOrCall(config.env),
-            os: detectOs(),
-            re: detectBrowser(),
-            user: undefined,
-            type: "CLIENT",
-            instant: dateNow(),
-            collector: "inspect-ng-collector-0.0.1"
-        };
+        this.config = config;
+        this.instanceEnvironment = instance;
         this.scheduledSessionSender = interval(this.delay)
             .pipe(tap(() => {
             if (this.sendSessionfinished) {
@@ -35,11 +18,31 @@ export class SessionManager {
             }
         }))
             .subscribe();
+        logInspect('SessionManager initialized');
     }
     addSessions(sessions) {
         this.sessionQueue.push(sessions);
         logInspect("added element to session queue, new size is: " + this.sessionQueue.length);
     }
+    newSession(url) {
+        if (this.currentSession) {
+            this.currentSession.end = dateNow();
+            if (this.config.exclude.every((e) => !e.test(this.currentSession.location))) {
+                this.addSessions(this.currentSession);
+            }
+            logInspect(() => prettySessionFormat(this.currentSession));
+        }
+        if (url) {
+            this.currentSession = {
+                '@type': "main",
+                user: this.config.user,
+                start: dateNow(),
+                type: "VIEW",
+                location: url,
+                restRequests: []
+            };
+        }
+    }
     sendSessions() {
         if (this.sessionQueue.length > 0) {
             this.getInsertedInstanceId().subscribe((id) => {
@@ -56,7 +59,7 @@ export class SessionManager {
                         mode: 'cors',
                         body: JSON.stringify(sessions)
                     };
-                    fetch(this.logServerMain, requestOptions)
+                    fetch(this.config.sessionApi, requestOptions)
                         .then(data => {
                         if (data.ok) {
                             logInspect('sessions sent successfully, queue size reset, new size is: ' + this.sessionQueue.length);
@@ -92,7 +95,7 @@ export class SessionManager {
         if (this.instance) {
             return this.instance;
         }
-        if (this.sendInstanceEnvFinished) {
+        if (this.sendInstanceEnvFinished) { // move up in send session  ? 
             this.sendInstanceEnvFinished = false;
             const requestOptions = {
                 method: 'POST',
@@ -103,13 +106,13 @@ export class SessionManager {
                 body: JSON.stringify(this.instanceEnvironment)
             };
             this.sessionSendAttempts++;
-            return from(fetch(this.logInstanceEnv, requestOptions)
+            return from(fetch(this.config.instanceApi, requestOptions)
                 .then(res => res.ok ? res.text().then(id => {
                 this.instance = new BehaviorSubject(id);
-                this.logServerMain = this.logServerMain.replace(':id', id);
+                this.config.sessionApi = this.config.sessionApi.replace(':id', id);
                 this.sessionSendAttempts = 0;
                 logInspect('Environement instance sent successfully');
-                return id; // return logserverMain
+                return id;
             }) : null)
                 .catch(err => {
                 console.warn(err);
@@ -120,25 +123,25 @@ export class SessionManager {
         }
         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: "16.2.12", ngImport: i0, type: SessionManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    getCurrentSession() {
+        return this.currentSession;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SessionManager, deps: [{ token: 'config' }, { token: 'instance' }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SessionManager, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SessionManager, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return []; } });
-//# 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, logInspect } 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        logInspect(\"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                    logInspect(`sending sessions, attempts:${++this.sessionSendAttempts}, queue size : ${sessions.length}`)\n\n                    const requestOptions: RequestInit = {\n                        method: 'PUT',\n                        headers: {\n                            'Content-Type': 'application/json',\n                        },\n                        mode : 'cors',\n                        body: JSON.stringify(sessions)\n                    };\n\n                    fetch(this.logServerMain, requestOptions)\n                    .then(data=> {\n                        if(data.ok){\n                            logInspect('sessions sent successfully, queue size reset, new size is: '+this.sessionQueue.length)\n                            this.sessionSendAttempts= 0;\n                        }else{\n                            console.warn(`Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`)//\n                            this.revertQueueSize(sessions);\n                        }\n                    })\n                    .catch(error => {\n                        console.warn(`Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`,error)//\n                        this.revertQueueSize(sessions);\n                    }).finally( ()=> {\n                        this.sendSessionfinished = true;\n                    })\n\n                }else {\n                    console.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            logInspect('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: RequestInit = {\n                \n                method: 'POST',\n                headers: {\n                    'Content-Type': 'application/json',\n                },\n                mode: 'cors',\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                logInspect('Environement instance sent successfully');\n                return id; // return logserverMain\n            }) : null)\n            .catch(err => {\n                console.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"]}
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['config']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['instance']
+                }] }]; } });
+//# 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 { Inject, Injectable, OnDestroy  } from '@angular/core';\nimport { InstanceEnvironment, MainSession } from './trace.model';\nimport { BehaviorSubject, from, interval, Observable, of, Subscription, tap } from 'rxjs';\nimport { dateNow,logInspect, prettySessionFormat } from './util';\nimport { TechnicalConf } from './configuration';\n\n\n@Injectable({ providedIn: 'root' })\nexport class SessionManager implements OnDestroy {\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    \n\n    currentSession!: MainSession;\n    config: TechnicalConf;\n    constructor(  @Inject('config') config: TechnicalConf,\n                  @Inject('instance') instance: InstanceEnvironment){\n        this.config = config;\n        this.instanceEnvironment = instance;\n        this.scheduledSessionSender = interval(this.delay)\n        .pipe(tap(()=> {\n            if(this.sendSessionfinished){\n                this.sendSessions();\n            }}))\n        .subscribe();\n        logInspect('SessionManager initialized');\n    }\n\n\n\n    addSessions(sessions:MainSession){\n        this.sessionQueue.push(sessions);\n        logInspect(\"added element to session queue, new size is: \"+ this.sessionQueue.length);\n    }\n\n\n    newSession(url?:string){\n        if(this.currentSession){\n            this.currentSession.end = dateNow();\n            if(this.config.exclude.every((e) => !e.test(this.currentSession.location))){\n                this.addSessions(this.currentSession);\n            }\n            logInspect(()=>prettySessionFormat(this.currentSession));\n        }\n        if(url){\n            this.currentSession = {\n                '@type': \"main\",\n                user: this.config.user,\n                start: dateNow(),\n                type: \"VIEW\",\n                location: url,\n                restRequests: []\n            }\n        }\n    }\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                    logInspect(`sending sessions, attempts:${++this.sessionSendAttempts}, queue size : ${sessions.length}`)\n\n                    const requestOptions: RequestInit = {\n                        method: 'PUT',\n                        headers: {\n                            'Content-Type': 'application/json',\n                        },\n                        mode : 'cors',\n                        body: JSON.stringify(sessions)\n                    };\n\n                    fetch(this.config.sessionApi, requestOptions)\n                    .then(data=> {\n                        if(data.ok){\n                            logInspect('sessions sent successfully, queue size reset, new size is: '+this.sessionQueue.length)\n                            this.sessionSendAttempts= 0;\n                        }else{\n                            console.warn(`Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`)//\n                            this.revertQueueSize(sessions);\n                        }\n                    })\n                    .catch(error => {\n                        console.warn(`Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`,error)//\n                        this.revertQueueSize(sessions);\n                    }).finally( ()=> {\n                        this.sendSessionfinished = true;\n                    })\n\n                }else {\n                    console.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            logInspect('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){// move up in send session  ? \n            this.sendInstanceEnvFinished = false;\n            const requestOptions: RequestInit = {\n                \n                method: 'POST',\n                headers: {\n                    'Content-Type': 'application/json',\n                },\n                mode: 'cors',\n                body: JSON.stringify(this.instanceEnvironment)\n            };\n            this.sessionSendAttempts++;\n            return from( fetch(this.config.instanceApi, requestOptions)\n            .then(res => res.ok ? res.text().then(id=> {\n                this.instance = new BehaviorSubject<string>(id);\n                this.config.sessionApi = this.config.sessionApi .replace(':id',id);\n                this.sessionSendAttempts=0;\n                logInspect('Environement instance sent successfully');\n                return id; \n            }) : null)\n            .catch(err => {\n                console.warn(err)\n                return null;\n            }).finally(()=> {\n                this.sendInstanceEnvFinished = true;\n            }))\n        }\n        return of(null);\n    }\n\n    \n\n     ngOnDestroy(): void {\n        if(this.scheduledSessionSender){\n            this.scheduledSessionSender.unsubscribe();\n        }\n    }\n\n    getCurrentSession() {\n        return this.currentSession;\n    }\n}\n"]}