@oneteme/inspect-ng-collector 1.2.0 → 1.3.0-beta.1

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

@@ -1,142 +1,35 @@
 import * as i0 from '@angular/core';
-import { Inject, Injectable, APP_INITIALIZER, ErrorHandler, NgModule } from '@angular/core';
+import { Injectable, inject, provideAppInitializer, ErrorHandler, NgModule } from '@angular/core';
 import { HttpResponse, HTTP_INTERCEPTORS } from '@angular/common/http';
-import { Router, NavigationStart, NavigationEnd } from '@angular/router';
-import { tap as tap$1, finalize } from 'rxjs/operators';
-import { interval, startWith, tap } from 'rxjs';
-import { DOCUMENT } from '@angular/common';
+import { finalize, interval, startWith, tap as tap$1 } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { NavigationStart, NavigationEnd, Router } from '@angular/router';
 
-const WIN = window;
 function dateNow() {
     return Date.now() / 1_000;
 }
-function initDebug(value) {
-    WIN["inspect"] = { app: value.app, user: value.user };
-}
-function logInspect(level, ...args) {
-    if (WIN["inspect"][level]) {
-        if (args.length == 1 && typeof args[0] == 'function') {
-            args = args[0]();
-            if (!Array.isArray(args)) {
-                args = [args];
-            }
-        }
-        console.log(`[INSPECT]-(${level})`, ...args);
-    }
-}
-function prettyActionUserFormat(session, userAction) {
-    let s = `(${session.location}) `;
-    if (userAction.type) {
-        s += `[${userAction.type}]`;
-    }
-    if (userAction.nodeName) {
-        s += `<${userAction.nodeName}>`;
-    }
-    if (userAction.name) {
-        s += `(${userAction.name}) `;
-    }
-    s += ` >> ${new Date(userAction.start * 1000).toISOString()}`;
-    return s;
-}
-function prettySessionFormat(session) {
-    let s = `[${session.name}]`;
-    if (session.user) {
-        s += `<${session.user}>`;
-    }
-    if (session.location) {
-        s += `(${session.location}) `;
-    }
-    s += prettyDurationFormat(session.start, session.end) + '\n';
-    session.restRequests.forEach(r => {
-        s += prettyRestRequestFormat(r) + '\n';
-    });
-    session.localRequests.forEach(r => {
-        s += prettyLocalRequestFormat(r) + '\n';
-    });
-    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 prettyLocalRequestFormat(local) {
-    let s = `  -  [${local.name}]`;
-    if (local.location) {
-        s += `(${local.location})`;
-    }
-    if (local.exception?.type) {
-        s += ` ${local.exception?.type}:`;
-    }
-    if (local.exception?.message) {
-        s += ` ${local.exception.message}`;
-    }
-    s += ` >> ${prettyDurationFormat(local.start, local.end)}`;
-    return s;
-}
-function prettyDurationFormat(start, end) {
-    return start && end ? `(in ${(end - start).toFixed(2)} s)` : '';
-}
-
-const SLASH = '/';
-const HOST_PATERN = /https?:\/\/[\w\-.]+(:\d{2,5})?\/?/;
-const PATH_PATERN = /[\w-]+(\/[\w-]+)*/;
-function validateAndGetConfig(conf) {
-    let host = matchRegex(getStringOrCall(conf.host), "host", HOST_PATERN);
-    let sessionApi = matchRegex(getStringOrCall(conf.sessionApi), "sessionApi", PATH_PATERN, "v3/trace/instance/:id/session");
-    let instanceApi = matchRegex(getStringOrCall(conf.instanceApi), "intanceApi", PATH_PATERN, "v3/trace/instance");
-    initDebug(conf.debug ?? { app: false, user: false });
+const DISPATCH = 'dispatch';
+const PRE_DISPATCH = 'pre-dispatch';
+const BEFOREUNLOAD = 'beforeunload';
+function createLogEntry(level, message, sessionId) {
     return {
-        user: typeof conf.user == 'function' ? conf.user : () => conf.user,
-        bufferMaxSize: requirePostitiveValue(getNumberOrCall(conf.bufferMaxSize), "bufferMaxSize", 1000),
-        delay: requirePostitiveValue(getNumberOrCall(conf.delay), "delay", 60000),
-        instanceApi: sessionApiURL(host, instanceApi),
-        sessionApi: instanceApiURL(host, sessionApi),
-        exclude: getRegArrOrCall(conf.exclude) || [],
-        debug: conf.debug ?? { app: false, user: false },
-        analytics: conf.analytics ?? false,
-        enabled: conf.enabled ?? false
+        "@type": "log",
+        level: level,
+        message: message,
+        instant: dateNow(),
+        sessionId: sessionId
     };
 }
-function GetInstanceEnvironement(conf) {
+function createReport(message) {
     return {
-        name: require(getStringOrCall(conf.name), 'name'),
-        version: getStringOrCall(conf.version),
-        address: undefined, //server side
-        env: require(getStringOrCall(conf.env), 'env'),
-        os: detectOs(),
-        re: detectBrowser(),
-        user: undefined, // cannot get user
-        type: "CLIENT",
+        "@type": "log",
+        level: "ERROR",
+        message: message,
         instant: dateNow(),
-        collector: "inspect-ng-collector-0.0.1"
     };
 }
+
+const SLASH$1 = '/';
 function getNumberOrCall(o) {
     return typeof o === "function" ? o() : o;
 }
@@ -191,14 +84,14 @@ function detectOs() {
     }
     return undefined;
 }
-function instanceApiURL(host, path) {
-    return toURL(host, path);
+function instanceApiURL$1(host, path) {
+    return toURL$1(host, path);
 }
-function sessionApiURL(host, path) {
-    return toURL(host, path);
+function sessionApiURL$1(host, path) {
+    return toURL$1(host, path);
 }
-function toURL(host, path) {
-    return host.endsWith(SLASH) || path.startsWith(SLASH) ? host + path : [host, path].join(SLASH);
+function toURL$1(host, path) {
+    return host.endsWith(SLASH$1) || path.startsWith(SLASH$1) ? host + path : [host, path].join(SLASH$1);
 }
 function matchRegex(v, name, pattern, defaultValue) {
     if (v && pattern.exec(v)) {
@@ -229,27 +122,109 @@ function require(v, name) {
     }
     throw new Error(`${name} property is required`);
 }
-
-class SessionManager {
-    constructor(config, instance) {
-        this.sessionQueue = [];
-        this.sessionSendAttempts = 0;
-        this.sendSessionfinished = true;
-        this.config = config;
-        this.instanceEnvironment = instance;
-        SessionManager._instance = this;
-        this.scheduledSessionSender = interval(config.delay)
-            .pipe(startWith(0))
-            .pipe(tap(() => {
-            if (this.sendSessionfinished) {
-                this.sendSessionfinished = false;
-                this.manageCache().finally(() => { this.sendSessionfinished = true; });
+function adaptedConfig(conf) {
+    return {
+        ...conf,
+        monitoring: {
+            ...conf.monitoring,
+            additionalProperties: String(conf.monitoring?.additionalProperties),
+            name: String(conf.monitoring?.name),
+            version: String(conf.monitoring?.version),
+            env: String(conf.monitoring?.env),
+            user: String(conf.monitoring?.user),
+            httpRoute: {
+                ...conf.monitoring?.httpRoute,
+                excludes: {
+                    path: (conf?.monitoring?.httpRoute?.excludes?.path).map(r => r.source) // convert to string array to conform to backend expectation
+                }
             }
-        }))
-            .subscribe();
-        logInspect('app', 'SessionManager initialized');
+        },
+        tracing: {
+            ...conf.tracing,
+            remote: {
+                ...conf.tracing?.remote,
+                '@type': "rest-rmt", // add this to conform to backend expectation
+            }
+        }
+    };
+}
+
+const SLASH = '/';
+const HOST_PATERN = /https?:\/\/[\w\-.]+(:\d{2,5})?\/?/;
+class ContextManager {
+    constructor(_instanceEnv, _techConfig) {
+        this._instanceEnv = _instanceEnv;
+        this._techConfig = _techConfig;
+    }
+    get techConfig() {
+        return this._techConfig;
+    }
+    get instanceEnv() {
+        return this._instanceEnv;
     }
     static get instance() {
+        if (!ContextManager._instance) {
+            console.warn("[Inspect-ng-collecotor] Error while initializing ContextManager");
+        }
+        return ContextManager._instance;
+    }
+    static init(conf) {
+        let id = crypto.randomUUID();
+        return ContextManager._instance = new ContextManager(ContextManager.createInstance(conf, id), ContextManager.validateAndGetConfig(conf, id));
+    }
+    static validateAndGetConfig(conf, instanceId) {
+        let host = matchRegex(getStringOrCall(conf?.tracing?.remote?.host), "host", HOST_PATERN);
+        let sessionApi = "v4/trace/instance/:id/session";
+        let instanceApi = "v4/trace/instance";
+        return {
+            user: getStringOrCall(conf?.monitoring?.user),
+            queueCapacity: requirePostitiveValue(getNumberOrCall(conf?.tracing?.queueCapacity), "queueCapacity", 1000),
+            interval: requirePostitiveValue(getNumberOrCall(conf?.scheduling?.interval), "interval", 60000),
+            delayIfPending: requirePostitiveValue(getNumberOrCall(conf?.tracing?.delayIfPending), "delayIfPending", 30),
+            instanceApi: sessionApiURL(host, instanceApi),
+            sessionApi: instanceApiURL(host, sessionApi).replace(':id', instanceId),
+            exclude: getRegArrOrCall(conf?.monitoring?.httpRoute?.excludes?.path) || [],
+            debugMode: conf.debugMode ?? false,
+            analytics: conf?.monitoring?.analytics?.enabled ?? false,
+            resources: conf?.monitoring?.resources?.enabled ?? false,
+            storage: conf?.monitoring?.storage?.enabled ?? false,
+            enabled: conf.enabled ?? false
+        };
+    }
+    static createInstance(conf, instanceId) {
+        return {
+            id: instanceId,
+            name: require(getStringOrCall(conf?.monitoring?.name), 'name'),
+            version: getStringOrCall(conf?.monitoring?.version),
+            address: undefined, //server side
+            env: require(getStringOrCall(conf?.monitoring?.env), 'env'),
+            os: detectOs(),
+            re: detectBrowser(),
+            user: undefined, // cannot get user
+            type: "CLIENT",
+            instant: dateNow(),
+            collector: "inspect-ng-collector-0.0.1",
+            resource: { maxHeap: (('memory' in performance) && performance.memory.jsHeapSizeLimit / (1024 * 1024)) || undefined },
+            additionalProperties: conf?.monitoring?.additionalProperties(),
+            configuration: adaptedConfig(conf)
+        };
+    }
+}
+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);
+}
+
+class SessionManager {
+    static get instance() {
+        if (!SessionManager._instance) {
+            SessionManager._instance = new SessionManager();
+        }
         return SessionManager._instance;
     }
     newSession(url) {
@@ -257,178 +232,105 @@ class SessionManager {
             this.currentSession.end = dateNow();
             this.currentSession.name = document.title;
             this.currentSession.location = document.URL;
-            if (this.config.exclude.every((e) => !e.test(this.currentSession.location))) {
-                this.sessionQueue.push(this.currentSession);
-                logInspect('app', `added element to session queue, new size is:${this.sessionQueue.length}`);
+            if (!ContextManager.instance.techConfig.exclude?.some((e) => e.test(this.currentSession.location))) {
+                window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: this.currentSession } }));
             }
-            logInspect('app', () => prettySessionFormat(this.currentSession));
         }
         if (url) {
             this.currentSession = {
-                '@type': "main",
-                user: this.config.user(),
+                '@type': "main-ses",
+                id: crypto.randomUUID(),
+                user: "",
                 start: dateNow(),
                 type: "VIEW",
                 location: url,
                 loading: true,
-                restRequests: [],
-                localRequests: [],
-                userActions: [],
                 exceptions: []
             };
+            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: this.currentSession } }));
         }
     }
-    manageCache() {
-        if (this.instanceEnvironment.id) {
-            return this.sendSessions();
-        }
-        return this.postInstanceEnv().then((id) => {
-            if (id) {
-                return this.sendSessions();
-            }
-            console.warn(`Error while attempting to send Environement instance, attempts ${this.sessionSendAttempts}`);
-            return Promise.reject(new Error('No instance id'));
-        });
-    }
-    sendSessions(instanceComplete) {
-        if (this.sessionQueue.length > 0) {
-            if (instanceComplete) {
-                this.config.sessionApi += "?end=" + new Date().toISOString();
-            }
-            this.sessionSendAttempts++;
-            let sessions = [...this.sessionQueue];
-            this.sessionQueue.splice(0, sessions.length); // add rest of sessions
-            logInspect('app', `sending sessions, attempts:${this.sessionSendAttempts}, queue size : ${sessions.length}`);
-            return this.putSessions(sessions)
-                .then(ok => {
-                if (ok) {
-                    logInspect('app', `sessions sent successfully, queue size reset, new size is: ${this.sessionQueue.length}`);
-                    this.sessionSendAttempts = 0;
-                    return sessions.length;
-                }
-                else {
-                    console.warn(`Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`); //
-                    this.revertQueueSize(sessions);
-                    return -1;
-                }
-            });
+    currentSessionID() {
+        if (this.currentSession) {
+            return this.currentSession.id;
         }
-        return Promise.resolve(0);
-    }
-    putSessions(sessionList) {
-        return fetch(this.config.sessionApi, {
-            method: 'PUT',
-            headers: { 'Content-Type': 'application/json' },
-            mode: 'cors',
-            body: JSON.stringify(sessionList)
-        })
-            .then(res => res.ok)
-            .catch(err => false);
+        window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createReport("no active session found ") } }));
+        return undefined;
     }
-    postInstanceEnv() {
-        this.sessionSendAttempts++;
-        return fetch(this.config.instanceApi, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            mode: 'cors',
-            body: JSON.stringify(this.instanceEnvironment)
-        })
-            .then(res => res.ok ? res.text().then(id => {
-            this.config.sessionApi = this.config.sessionApi.replace(':id', id);
-            logInspect('app', 'Environement instance sent successfully', id);
-            this.sessionSendAttempts = 0;
-            return this.instanceEnvironment.id = id;
-        }) : null)
-            .catch(err => null);
+    getCurrentSession() {
+        return this.currentSession;
     }
-    revertQueueSize(sessions) {
-        this.sessionQueue.unshift(...sessions);
-        if (this.sessionQueue.length > this.config.bufferMaxSize) {
-            let diff = this.sessionQueue.length - this.config.bufferMaxSize;
-            this.sessionQueue = this.sessionQueue.slice(0, this.config.bufferMaxSize);
-            logInspect('app', `Buffer size exeeded the max size,last sessions have been removed from buffer, (number of sessions removed):${diff}`);
+    addException(exception) {
+        if (this.currentSession) {
+            this.currentSession.exceptions.push(exception);
         }
-    }
-    ngOnDestroy() {
-        if (this.scheduledSessionSender) {
-            this.scheduledSessionSender.unsubscribe();
+        else {
+            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createReport("no active session found ") } }));
         }
     }
-    getCurrentSession() {
-        return this.currentSession;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: SessionManager, deps: [{ token: 'config' }, { token: 'instance' }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: SessionManager, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: SessionManager, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['config']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['instance']
-                }] }] });
 
-class HttpInterceptorService {
-    constructor(SessionManager) {
-        this.SessionManager = SessionManager;
-    } // change this to session manager
-    intercept(req, next) {
+class RestRequestMonitor {
+    constructor(restRequest) {
         const start = dateNow();
-        let status, responseBody = '', exception;
-        let id;
-        return next.handle(req).pipe(tap$1((event) => {
-            if (event instanceof HttpResponse) {
-                status = +event.status;
-                responseBody = event.body;
-                id = getReqid(event.headers);
-            }
-        }, error => {
-            id = getReqid(error.headers);
+        const url = toHref(restRequest.urlWithParams);
+        const auth_user = extractAuthSchemeAnduser(restRequest.headers);
+        this.restRequest = {
+            "@type": "http-req",
+            id: crypto.randomUUID(),
+            method: restRequest.method,
+            protocol: url.protocol.slice(0, -1),
+            host: exctractHost(url.host),
+            port: +url.port || -1,
+            path: url.pathname,
+            query: url.search.slice(1, url.search.length),
+            contentType: restRequest.responseType,
+            authScheme: auth_user.authScheme,
+            user: auth_user.user,
+            ouDataSize: sizeOf(restRequest.body),
+            start: start,
+            sessionId: SessionManager.instance.currentSessionID()
+        };
+    }
+    postProcess(event, error) {
+        let status = 0, exception = null;
+        if (event) {
+            status = +event.status;
+            this.restRequest.inDataSize = sizeOf(event.body);
+            this.assertSessionID(this.restRequest.id, event.headers);
+        }
+        if (error) {
+            this.assertSessionID(this.restRequest.id, error?.headers);
             status = +error.status;
             exception = {
                 type: error.name,
                 message: error.error && error.status ? JSON.stringify(error.error) : error.message
             };
-        }), finalize(() => {
-            try {
-                if (this.SessionManager.getCurrentSession()) {
-                    const url = toHref(req.urlWithParams);
-                    const auth_user = extractAuthSchemeAnduser(req.headers);
-                    this.SessionManager.getCurrentSession().restRequests.push({
-                        id: id,
-                        method: req.method,
-                        protocol: url.protocol.slice(0, -1),
-                        host: exctractHost(url.host),
-                        port: +url.port || -1,
-                        path: url.pathname,
-                        query: url.search.slice(1, url.search.length),
-                        contentType: req.responseType,
-                        authScheme: auth_user.authScheme,
-                        user: auth_user.user,
-                        status: +status,
-                        inDataSize: sizeOf(responseBody),
-                        ouDataSize: sizeOf(req.body),
-                        start: start,
-                        end: dateNow(),
-                        exception: exception
-                    });
-                }
-            }
-            catch (err) {
-                console.warn(err);
+        }
+        this.restRequest.end = dateNow();
+        this.restRequest.status = +status;
+        let stage = {
+            "@type": "http-stg",
+            name: "PROCESS",
+            start: this.restRequest.start,
+            end: dateNow(),
+            order: 0,
+            exception: exception,
+            requestId: this.restRequest.id
+        };
+        window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: this.restRequest } }));
+        window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: stage } }));
+    }
+    assertSessionID(id, headers) {
+        if (headers?.has('x-tracert')) {
+            if (id !== headers.get('x-tracert')) {
+                window.dispatchEvent(new CustomEvent(DISPATCH, {
+                    detail: { traces: createReport("The received x-tracert header (" + headers.get('x-tracert') + ") does not match the request id (" + id + ")") }
+                }));
             }
-        }));
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: HttpInterceptorService, deps: [{ token: SessionManager }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: HttpInterceptorService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: HttpInterceptorService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: SessionManager }] });
 function toHref(url) {
     const href = document.createElement('a');
     href.setAttribute('href', url);
@@ -444,7 +346,7 @@ function extractAuthSchemeAnduser(headers) {
         authScheme: undefined
     };
     try {
-        auth_user.authScheme = headers.get('authorization').match(/^(\w+) /)?.at(1);
+        auth_user.authScheme = headers.has('authorization') && headers.get('authorization').match(/^(\w+) /)?.at(1);
         switch (auth_user.authScheme) {
             case "Basic":
                 auth_user.user = atob(headers.get('authorization').split(" ")[1]).toString().split(':')[0];
@@ -457,18 +359,213 @@ function extractAuthSchemeAnduser(headers) {
             }
         }
     }
-    catch (err) { }
+    catch (err) {
+        createReport(JSON.stringify(err));
+    }
     return auth_user;
 }
-function getReqid(headers) {
-    return headers.has('x-tracert')
-        ? headers.get('x-tracert')
-        : undefined;
-}
 function sizeOf(body) {
     return body ? JSON.stringify(body).length : 0;
 }
 
+class HttpInterceptorService {
+    constructor() { }
+    intercept(req, next) {
+        let restRequestMonitor = new RestRequestMonitor(req);
+        let e;
+        window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: restRequestMonitor.restRequest } }));
+        req = req.clone({ headers: req.headers.set('x-tracert', restRequestMonitor.restRequest.id) });
+        return next.handle(req).pipe(tap((event) => {
+            if (event instanceof HttpResponse) {
+                e = event;
+            }
+        }, error => {
+            e = error;
+        }), finalize(() => {
+            e instanceof HttpResponse ? restRequestMonitor.postProcess(e, null) : restRequestMonitor.postProcess(null, e ?? {
+                status: 0,
+                name: "IOException",
+                message: "The remote server is unavailable.",
+            });
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: HttpInterceptorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: HttpInterceptorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: HttpInterceptorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class GlobalErrorHandlerService {
+    handleError(error) {
+        try {
+            SessionManager.instance.addException({
+                type: error?.name,
+                message: error?.message
+            });
+        }
+        catch (e) {
+            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createReport("Erreur dans GlobalErrorHandlerService: " + JSON.stringify(e)) } }));
+        }
+        throw error;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: GlobalErrorHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: GlobalErrorHandlerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: GlobalErrorHandlerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+function eventTraceScheduledDispatcher() {
+    return EventTraceScheduledDispatcherService._instance = new EventTraceScheduledDispatcherService();
+}
+class EventTraceScheduledDispatcherService {
+    constructor() {
+        this.traceQueue = new Set();
+        this.sessionSendAttempts = 0;
+        this.sendSessionfinished = true;
+        this.instanceSaved = false;
+        interval(ContextManager.instance.techConfig.interval)
+            .pipe(startWith(0))
+            .pipe(tap$1(() => {
+            if (this.sendSessionfinished) {
+                this.sendSessionfinished = false;
+                setTimeout(() => window.dispatchEvent(new CustomEvent(PRE_DISPATCH)), 50);
+                this.Dispatch().finally(() => { this.sendSessionfinished = true; });
+            }
+        }))
+            .subscribe();
+        window.addEventListener(DISPATCH, (e) => {
+            e.detail.traces && this.addtoQueue(e.detail.traces);
+            e.detail.force && this.sendSessions(true);
+        });
+    }
+    Dispatch() {
+        if (this.instanceSaved) {
+            return this.sendSessions();
+        }
+        return this.postInstanceEnv().then((ok) => {
+            if (ok) {
+                return this.sendSessions();
+            }
+            this.sessionSendAttempts % 5 == 0 && console.warn(`Error while attempting to send Environement instance, attempts ${this.sessionSendAttempts}`);
+            return Promise.reject(new Error('No instance id'));
+        });
+    }
+    sendSessions(instanceComplete) {
+        if (this.traceQueue.size > 0) {
+            let uri = ContextManager.instance.techConfig.sessionApi + "?attempts=" + ++this.sessionSendAttempts;
+            if (instanceComplete) {
+                uri += "&end=" + new Date().toISOString();
+            }
+            let sessions = this.traceQueue;
+            this.traceQueue = new Set();
+            return fetch(uri, this.getRequestInit(sessions))
+                .then(res => {
+                if (res.ok) {
+                    this.sessionSendAttempts = 0;
+                    return sessions.size;
+                }
+                return this.handleEventTraceSavingError(sessions);
+            })
+                .catch(() => this.handleEventTraceSavingError(sessions));
+        }
+        return Promise.resolve(0);
+    }
+    handleEventTraceSavingError(sessions) {
+        this.sessionSendAttempts % 5 == 0 && console.warn(`Error while attempting to send sessions, attempts: ${this.sessionSendAttempts}`);
+        this.revertQueueSize(sessions);
+        return -1;
+    }
+    getRequestInit(sessionList) {
+        return {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            mode: 'cors',
+            body: JSON.stringify(Array.from(sessionList))
+        };
+    }
+    postInstanceEnv() {
+        this.sessionSendAttempts++;
+        return fetch(ContextManager.instance.techConfig.instanceApi, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            mode: 'cors',
+            body: JSON.stringify(ContextManager.instance.instanceEnv)
+        })
+            .then(res => res.ok ? res.text().then(id => {
+            this.sessionSendAttempts = 0;
+            return this.instanceSaved = true;
+        }) : false)
+            .catch(err => false);
+    }
+    revertQueueSize(sessions) {
+        sessions.forEach(session => this.traceQueue.add(session));
+        if (this.traceQueue.size > ContextManager.instance.techConfig.queueCapacity) {
+            const items = Array.from(this.traceQueue).slice(0, ContextManager.instance.techConfig.queueCapacity);
+            this.traceQueue = new Set(items);
+        }
+    }
+    async addtoQueue(event) {
+        try {
+            if (event) {
+                this.traceQueue.add(event);
+            }
+        }
+        catch (e) {
+            this.addtoQueue(createReport(String(e)));
+        }
+    }
+}
+
+function routeHandler(event) {
+    if (event instanceof NavigationStart) {
+        SessionManager.instance.newSession(event.url);
+    }
+    if (event instanceof NavigationEnd) {
+        delete SessionManager.instance?.getCurrentSession().loading;
+    }
+}
+function windowUnloadHandler(event) {
+    if (!SessionManager.instance.getCurrentSession().loading) {
+        SessionManager.instance.newSession();
+    }
+    window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { force: true } }));
+}
+
+function machineRessourceUsageHandler(event) {
+    window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: getMemoryInfo() } }));
+}
+function getMemoryInfo() {
+    try {
+        const memory = performance.memory;
+        return {
+            '@type': 'rsrc-usg',
+            instant: dateNow(),
+            usedHeap: memory.usedJSHeapSize / (1024 * 1024),
+            commitedHeap: memory.totalJSHeapSize / (1024 * 1024),
+        };
+    }
+    catch (e) {
+        createReport(JSON.stringify(e));
+    }
+    return null;
+}
+
+function routerEventsListener() {
+    inject(Router).events.subscribe(routeHandler);
+}
+function beforeUnloadListener() {
+    window.addEventListener(BEFOREUNLOAD, windowUnloadHandler);
+}
+function beforeDispatchListener() {
+    if (ContextManager.instance.techConfig.resources && 'memory' in performance) {
+        window.addEventListener(PRE_DISPATCH, machineRessourceUsageHandler);
+    }
+}
+
 const genericMap = [
     t => t.getAttribute('placeholder'),
     t => t.getAttribute('title'),
@@ -518,125 +615,256 @@ function extractName(t) {
     return null;
 }
 
-class AnalyticsCollector {
-    constructor(document, sessionManager) {
-        this.document = document;
-        this.sessionManager = sessionManager;
-        this.eventHandlers = {
-            'click': (target) => this.lookUpChild(target, 1),
-        };
-        this.patchedEvent = {};
-        this.elementsWithClickListeners = new WeakSet();
-    }
-    subscribeToEvents() {
-        const body = this.document.body;
-        body.addEventListener('click', (event) => this.globalHandler(event), true);
-        body.addEventListener('change', (event) => this.globalHandler(event), true);
-        body.addEventListener('scrollend', (event) => this.globalHandler(event), true);
-        body.addEventListener('dragend', (event) => this.globalHandler(event), true);
-        this.document.addEventListener('DOMContentLoaded', (event) => this.globalHandler(event), true);
-        /* let that =this;
-     
-         const originalAddEventListener = EventTarget.prototype.addEventListener;
-         EventTarget.prototype.addEventListener = function(type: string, listener: any, options?: boolean | AddEventListenerOptions) {
-           if(type === "click"){
-               that.elementsWithClickListeners.add(this);
-               const wrapperListener = (event: any) => {
-                 if(that.elementsWithClickListeners.has(event.currentTarget)){
-                   console.log('click event',event);
-                   that.GlobalHandler(event);
-                 }
-                 return listener.apply(this, arguments);
-               };
-               return originalAddEventListener.apply(this,[type,wrapperListener,options])
-           }
-           return originalAddEventListener.call(this, type, listener, options);
-         }*/
-    }
-    globalHandler(event) {
-        // event.stopPropagation()
-        // event.preventDefault()
-        let target = event.target;
-        let eventType = event.type;
+let eventHandlers = {
+    'click': (target) => lookUpChild(target, 1),
+};
+function analyticsEventsListener() {
+    if (ContextManager.instance.techConfig.analytics) {
         try {
-            if (this.eventHandlers.hasOwnProperty(eventType) && !this.eventHandlers[eventType](target)) {
-                return;
-            }
-            this.addActionUser(eventType, target);
+            const body = window.document.body;
+            body.addEventListener('click', globalHandler, true);
+            body.addEventListener('change', (event) => globalHandler(event), true);
+            body.addEventListener('scrollend', (event) => globalHandler(event), true);
+            body.addEventListener('dragend', (event) => globalHandler(event), true);
+            window.document.addEventListener('DOMContentLoaded', (event) => globalHandler(event), true);
         }
-        catch (err) {
-            console.warn(err);
+        catch (e) {
+            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createReport("Error while subscribing to analytics user events: " + JSON.stringify(e)) } }));
         }
     }
-    lookUpChild(t, depth) {
-        if (t.hasChildNodes() && t.children.length <= 5) {
-            if (++depth > 5) {
-                return false;
-            }
-            return Array.from(t.childNodes).reduce((acc, c) => acc && this.lookUpChild(c, depth), true);
+}
+function globalHandler(event) {
+    let target = event.target;
+    let eventType = event.type;
+    try {
+        if (eventHandlers.hasOwnProperty(eventType) && !eventHandlers[eventType](target)) {
+            return;
         }
-        return true;
+        addActionUser(eventType, target);
     }
-    addActionUser(eventType, target) {
-        const ua = {
-            type: eventType,
-            start: dateNow(),
-            name: extractName(target),
-            nodeName: target.tagName?.toLowerCase(),
-        };
-        logInspect('user', () => prettyActionUserFormat(this.sessionManager.getCurrentSession(), ua));
-        this.sessionManager.getCurrentSession().userActions.push(ua);
+    catch (err) {
+        console.warn(err);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: AnalyticsCollector, deps: [{ token: DOCUMENT }, { token: SessionManager }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: AnalyticsCollector, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: AnalyticsCollector, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: Document, decorators: [{
-                    type: Inject,
-                    args: [DOCUMENT]
-                }] }, { type: SessionManager }] });
+function lookUpChild(t, depth) {
+    if (t.hasChildNodes() && t.children.length <= 5) {
+        if (++depth > 5) {
+            return false;
+        }
+        return Array.from(t.childNodes).reduce((acc, c) => acc && lookUpChild(c, depth), true);
+    }
+    return true;
+}
+function addActionUser(eventType, target) {
+    const ua = {
+        '@type': "user-act",
+        type: eventType,
+        start: dateNow(),
+        name: extractName(target),
+        nodeName: target.tagName?.toLowerCase(),
+        sessionId: SessionManager.instance?.getCurrentSession().id
+    };
+    //  window.dispatchEvent(new CustomEvent( DISPATCH ,{ detail :  { traces:ua }}));
+}
 
-class GlobalErrorHandlerService {
-    constructor(sessionManager) {
-        this.sessionManager = sessionManager;
+const WIN = window;
+function eventTraceDebugger() {
+    EventTraceDebugger._instance = new EventTraceDebugger();
+}
+class EventTraceDebugger {
+    constructor() {
+        this.restRequests = [];
+        this.httpRequestStages = [];
+        this.localRequests = [];
+        this.userActions = [];
+        this.logEntries = [];
+        try {
+            if (ContextManager.instance.techConfig.debugMode || WIN['inspect']) {
+                window.addEventListener(DISPATCH, this.handleTraces.bind(this));
+            }
+            WIN["inspect-setup"] = {
+                init: () => {
+                    WIN['inspect'] = true;
+                    EventTraceDebugger.init();
+                },
+                printConfig: () => console.log(ContextManager.instance.techConfig),
+                printInstance: () => console.log(ContextManager.instance)
+            };
+        }
+        catch (e) {
+            console.warn(e);
+            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createReport("Error while setting up debug mode: " + JSON.stringify(e)) } }));
+        }
     }
-    handleError(error) {
-        this.sessionManager.getCurrentSession().exceptions.push({
-            type: error?.name,
-            message: error?.message
+    handleTraces(e) {
+        let trace = e.detail.traces;
+        if (trace && !e.detail.force) {
+            switch (trace['@type']) {
+                case 'main-ses':
+                    if (trace.end) {
+                        console.log(this.prettySessionFormat(SessionManager.instance.currentSession));
+                    }
+                    break;
+                case 'http-req':
+                    this.restRequests.push(trace);
+                    break;
+                case 'http-stg':
+                    this.httpRequestStages.push(trace);
+                    break;
+                case 'user-act':
+                    this.userActions.push(trace);
+                    break;
+                case 'locl-req':
+                    this.localRequests.push(trace);
+                    break;
+                case 'log':
+                    trace.sessionId ? this.logEntries.push(trace) : console.warn(this.prettyLogEntryFormat(trace));
+                    break;
+                case 'rsrc-usg':
+                    console.log(this.prettyMachineResourceUsageFormat(trace));
+                    break;
+            }
+        }
+    }
+    static init() {
+        return EventTraceDebugger._instance = new EventTraceDebugger();
+    }
+    prettySessionFormat(session) {
+        let s = `[${session.name}]`;
+        if (session.user) {
+            s += `<${session.user}>`;
+        }
+        if (session.location) {
+            s += `(${session.location}) `;
+        }
+        s += this.prettyDurationFormat(session.start, session.end) + '\n';
+        s += this.getChildPrint(this.restRequests, this.prettyRestRequestFormat.bind(this));
+        s += this.getChildPrint(this.localRequests, this.prettyLocalRequestFormat.bind(this));
+        s += this.getChildPrint(this.userActions, this.prettyActionUserFormat.bind(this));
+        s += this.getChildPrint(this.logEntries, this.prettyLogEntryFormat.bind(this));
+        this.resetList();
+        return s;
+    }
+    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;
+        }
+        s += ` >> ${rest.status} `;
+        s += this.prettyDurationFormat(rest.start, rest.end) + '\n';
+        this.httpRequestStages.filter((s) => s.requestId == rest.id).forEach((stage) => {
+            s += this.prettyHttpRequestStageFormat(stage);
         });
-        throw error;
+        return s;
+    }
+    prettyHttpRequestStageFormat(stage) {
+        let s = `         -  [${stage.name}]`;
+        s += " >> ";
+        if (stage.exception?.type) {
+            s += ` ${stage.exception?.type}:`;
+        }
+        if (stage.exception?.message) {
+            s += ` ${stage.exception.message}`;
+        }
+        s += ` ${this.prettyDurationFormat(stage.start, stage.end)}`;
+        return s;
+    }
+    prettyLocalRequestFormat(local) {
+        let s = `  -  [${local.name}]`;
+        if (local.location) {
+            s += `(${local.location})`;
+        }
+        s += " >> ";
+        if (local.exception?.type) {
+            s += ` ${local.exception?.type}:`;
+        }
+        if (local.exception?.message) {
+            s += ` ${local.exception.message}`;
+        }
+        s += ` ${this.prettyDurationFormat(local.start, local.end)}`;
+        return s;
+    }
+    prettyLogEntryFormat(log) {
+        let s = `  -  [${log.level}]`;
+        if (log.message) {
+            s += ` ${log.message}`;
+        }
+        s += ` >> ${new Date(log.instant * 1000).toISOString()}`;
+        return s;
+    }
+    prettyMachineResourceUsageFormat(resource) {
+        return `  -  [METRIC] heap :${resource.usedHeap.toFixed(2)}/${resource.commitedHeap.toFixed(2)} >> ${new Date(resource.instant * 1000).toISOString()}`;
+    }
+    prettyActionUserFormat(userAction) {
+        let s = `  -  `;
+        if (userAction.type) {
+            s += `[${userAction.type}]`;
+        }
+        if (userAction.nodeName) {
+            s += `<${userAction.nodeName}>`;
+        }
+        if (userAction.name) {
+            s += `(${userAction.name}) `;
+        }
+        s += ` >> ${new Date(userAction.start * 1000).toISOString()}`;
+        return s;
+    }
+    getChildPrint(o, print) {
+        let s = "";
+        if (o.length) {
+            o = o.filter((r) => {
+                if (r.sessionId === SessionManager.instance.currentSessionID()) {
+                    s += print(r) + '\n';
+                    return false;
+                }
+                return true;
+            });
+            const remainingRequests = o.map((r) => print(r)).join('\n');
+            if (remainingRequests) {
+                console.warn(remainingRequests);
+            }
+        }
+        return s;
+    }
+    prettyDurationFormat(start, end) {
+        return start && end ? `(in ${(end - start).toFixed(2)} s)` : '';
+    }
+    resetList() {
+        this.restRequests = [];
+        this.httpRequestStages = [];
+        this.localRequests = [];
+        this.userActions = [];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: GlobalErrorHandlerService, deps: [{ token: SessionManager }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: GlobalErrorHandlerService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: GlobalErrorHandlerService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: SessionManager }] });
 
 class NgCollectorModule {
+    static { this.forRootCalled = false; }
     static forRoot(configuration) {
-        if (configuration?.enabled) {
+        console.log("forRootCalled");
+        if (configuration?.enabled && !NgCollectorModule.forRootCalled) {
+            NgCollectorModule.forRootCalled = true;
             try {
-                let config = validateAndGetConfig(configuration);
-                let instance = GetInstanceEnvironement(configuration);
-                let deps = [Router, SessionManager];
-                logInspect('app', JSON.stringify(config));
-                logInspect('app', JSON.stringify(instance));
-                config.analytics && deps.push(AnalyticsCollector);
+                ContextManager.init(configuration);
                 return {
                     ngModule: NgCollectorModule,
                     providers: [
-                        SessionManager,
-                        { provide: APP_INITIALIZER, useFactory: initializeEvents, deps: deps, multi: true },
+                        provideAppInitializer(initializeEvents),
                         { provide: HTTP_INTERCEPTORS, useClass: HttpInterceptorService, multi: true },
-                        { provide: 'instance', useValue: instance },
-                        { provide: 'config', useValue: config },
                         { provide: ErrorHandler, useClass: GlobalErrorHandlerService }
                     ]
                 };
@@ -649,42 +877,29 @@ class NgCollectorModule {
             ngModule: NgCollectorModule
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgCollectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.3", ngImport: i0, type: NgCollectorModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgCollectorModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: NgCollectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.3", ngImport: i0, type: NgCollectorModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: NgCollectorModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NgCollectorModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: NgCollectorModule, decorators: [{
             type: NgModule
         }] });
-function initializeEvents(router, sessionManager, analyticsCollector) {
-    return () => {
-        logInspect('app', 'initialize routing events listeners');
-        window.addEventListener('beforeunload', event => {
-            if (!sessionManager.getCurrentSession().loading) {
-                sessionManager.newSession();
-            }
-            sessionManager.sendSessions(true);
-        });
-        router.events.subscribe(event => {
-            if (event instanceof NavigationStart) {
-                sessionManager.newSession(event.url);
-            }
-            if (event instanceof NavigationEnd) {
-                delete sessionManager.getCurrentSession().loading;
-            }
-        });
-        if (analyticsCollector) {
-            analyticsCollector.subscribeToEvents();
-        }
-    };
+function initializeEvents() {
+    eventTraceScheduledDispatcher();
+    eventTraceDebugger();
+    analyticsEventsListener();
+    //storageEventListener();
+    beforeDispatchListener();
+    beforeUnloadListener();
+    routerEventsListener();
 }
 
 function TraceableStage() {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = function (...args) {
-            if (SessionManager.instance) {
-                let session = SessionManager.instance.getCurrentSession();
+            if (SessionManager) {
+                let session = SessionManager.instance?.getCurrentSession();
                 let exception;
                 let start, end;
                 start = Date.now();
@@ -713,14 +928,19 @@ function TraceableStage() {
                 }
                 finally {
                     end = Date.now();
-                    SessionManager.instance.getCurrentSession().localRequests.push({
-                        name: propertyKey,
-                        location: target.constructor.name,
-                        user: session.user,
-                        start: start,
-                        end: end,
-                        exception: exception
-                    });
+                    window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: {
+                                "@type": "locl-req",
+                                id: crypto.randomUUID(),
+                                name: propertyKey,
+                                location: target.constructor.name,
+                                user: session.user,
+                                start: start,
+                                end: end,
+                                exception: exception,
+                                sessionId: SessionManager.instance.currentSessionID()
+                            }
+                        }
+                    }));
                 }
             }
         };
@@ -728,6 +948,24 @@ function TraceableStage() {
     };
 }
 
+class LogService {
+    static info(message) {
+        if (message) {
+            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createLogEntry("INFO", message, SessionManager.instance?.currentSessionID()) } }));
+        }
+    }
+    static warn(message) {
+        if (message) {
+            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createLogEntry("WARN", message, SessionManager.instance?.currentSessionID()) } }));
+        }
+    }
+    static error(message) {
+        if (message) {
+            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createLogEntry("ERROR", message, SessionManager.instance?.currentSessionID()) } }));
+        }
+    }
+}
+
 /*
  * Public API Surface of inspect-ng-collector
  */
@@ -736,5 +974,5 @@ function TraceableStage() {
  * Generated bundle index. Do not edit.
  */
 
-export { NgCollectorModule, TraceableStage, initializeEvents };
+export { LogService, NgCollectorModule, TraceableStage, initializeEvents };
 //# sourceMappingURL=oneteme-inspect-ng-collector.mjs.map