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

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

@@ -1,97 +1,74 @@
 import * as i0 from '@angular/core';
-import { Injectable, APP_INITIALIZER, ErrorHandler, NgModule } from '@angular/core';
-import { HttpErrorResponse, HttpResponse, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { InjectionToken, Inject, Injectable, APP_INITIALIZER, ErrorHandler, NgModule } from '@angular/core';
+import { HttpResponse, HttpErrorResponse, HTTP_INTERCEPTORS } from '@angular/common/http';
 import { finalize, interval, startWith, tap as tap$1 } from 'rxjs';
 import { tap } from 'rxjs/operators';
 import { NavigationStart, NavigationEnd, NavigationCancel, Router } from '@angular/router';
 
-const WIN = window;
-function dateNow() {
-    return Date.now() / 1_000;
-}
 var RequestMask;
 (function (RequestMask) {
     RequestMask[RequestMask["LOCAL"] = 1] = "LOCAL";
     RequestMask[RequestMask["REST"] = 4] = "REST";
 })(RequestMask || (RequestMask = {}));
-const DISPATCH = 'dispatch';
-const PRE_DISPATCH = 'pre-dispatch';
-const BEFOREUNLOAD = 'beforeunload';
-function createLogEntry(level, message, sessionId) {
-    return {
-        "@type": "00",
+const TRACE_TYPE_LOG = '00';
+const TRACE_TYPE_RESOURCE_USAGE = '01';
+const TRACE_TYPE_COLLECTOR_CONFIGURATION = '02';
+const TRACE_TYPE_SESSION_MASK_UPDATE = '03';
+const TRACE_TYPE_MAIN_SESSION = '10';
+const TRACE_TYPE_MAIN_SESSION_CALLBACK = '11';
+const TRACE_TYPE_LOCAL_REQUEST = '110';
+const TRACE_TYPE_LOCAL_REQUEST_CALLBACK = '111';
+const TRACE_TYPE_REST_REQUEST = '120';
+const TRACE_TYPE_REST_REQUEST_CALLBACK = '121';
+const TRACE_TYPE_HTTP_REQUEST_STAGE = '220';
+const TRACE_TYPE_USER_ACTION = '300';
+function dateNow() {
+    return Date.now() / 1_000;
+}
+
+const eventTarget = new EventTarget();
+const TRACE = 'trace', EXPORT = 'export', SHUTDOWN = 'shutdown', RELOAD = 'reload';
+const WIN = window;
+function dispatchReport(message, error) {
+    dispatchLog("REPORT", `${message} ${error && JSON.stringify(error)}`);
+}
+function dispatchLog(level, message, sessionId) {
+    dispatchTraces({
+        "@type": TRACE_TYPE_LOG,
         level: level,
         message: message,
         instant: dateNow(),
         sessionId: sessionId
-    };
+    });
 }
-function createReport(message) {
-    return {
-        "@type": "00",
-        level: "ERROR",
-        message: message,
-        instant: dateNow(),
-    };
+function dispatchTraces(...traces) {
+    eventTarget.dispatchEvent(new CustomEvent(TRACE, { detail: { traces } }));
 }
-
-const SLASH$1 = '/';
-function getNumberOrCall(o) {
-    return typeof o === "function" ? o() : o;
+function dispatchExport() {
+    eventTarget.dispatchEvent(new CustomEvent(EXPORT));
 }
-function getStringOrCall(o) {
-    return typeof o === "function" ? o() : o;
+function dispatchReload() {
+    eventTarget.dispatchEvent(new CustomEvent(RELOAD));
 }
-function getRegArrOrCall(o) {
-    return typeof o === "function" ? o() : o;
+function dispatchShutown() {
+    eventTarget.dispatchEvent(new CustomEvent(SHUTDOWN));
 }
-function detectBrowser() {
-    try {
-        const agent = window.navigator.userAgent.toLowerCase();
-        switch (true) {
-            case agent.indexOf('edg') > -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';
-            case agent.indexOf('msie') > -1:
-                return 'Microsoft Internet Explorer';
-        }
-    }
-    catch (e) {
-        console.error(e);
-    }
-    return undefined;
+function addTraceListener(fn) {
+    eventTarget.addEventListener(TRACE, fn);
 }
-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 addExportListener(fn) {
+    eventTarget.addEventListener(EXPORT, fn);
+}
+function addReloadListener(fn) {
+    eventTarget.addEventListener(RELOAD, fn);
 }
-function toURL$1(host, path) {
-    return host.endsWith(SLASH$1) || path.startsWith(SLASH$1) ? host + path : [host, path].join(SLASH$1);
+function addShutdownListener(fn) {
+    eventTarget.addEventListener(SHUTDOWN, fn);
+}
+
+const HOST_PATERN = /https?:\/\/[\w\-.]+(:\d{2,5})?\/?/;
+function getOrCall(o) {
+    return typeof o === "function" ? o() : o;
 }
 function matchRegex(v, name, pattern, defaultValue) {
     if (v && pattern.exec(v)) {
@@ -116,7 +93,7 @@ function requirePostitiveValue(v, name, defaultValue) {
     }
     throw new Error(`bad value ${name}=${v} <= 0`);
 }
-function require(v, name) {
+function require$1(v, name) {
     if (v != undefined) {
         return v;
     }
@@ -131,11 +108,11 @@ function adaptedConfig(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),
+            additionalProperties: String(conf.additionalProperties),
+            name: String(conf.name),
+            version: String(conf.version),
+            env: String(conf.env),
+            user: String(conf.user),
             httpRoute: {
                 ...conf.monitoring?.httpRoute,
                 excludes: {
@@ -147,283 +124,305 @@ function adaptedConfig(conf) {
             ...conf.tracing,
             remote: {
                 ...conf.tracing?.remote,
-                '@type': "02",
+                '@type': TRACE_TYPE_COLLECTOR_CONFIGURATION,
                 retentionMaxAge: (conf.tracing?.remote?.retentionMaxAge ?? 10) * 60 * 60 * 24
             }
         }
     };
 }
-
-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;
+function validateAndGetConfig(conf, instanceId) {
+    const host = matchRegex(getOrCall(conf?.tracing?.remote?.host), "host", HOST_PATERN);
+    return {
+        user: conf?.user,
+        queueCapacity: requirePostitiveValue(getOrCall(conf?.tracing?.queueCapacity), "queueCapacity", 1000),
+        interval: requirePostitiveValue(getOrCall(conf?.scheduling?.interval), "interval", 60000),
+        instanceApi: new URL('v4/trace/instance', host).href,
+        sessionApi: new URL(`v4/trace/instance/${instanceId}/session`, host).href,
+        exclude: getOrCall(conf?.monitoring?.httpRoute?.excludes?.path) || [],
+        hostExcludes: conf?.monitoring?.httpRequest?.excludes?.host || [],
+        debugMode: !!conf.debugMode,
+        analytics: !!conf?.monitoring?.analytics?.enabled,
+        resources: !!conf?.monitoring?.resources?.enabled,
+        storage: !!conf?.monitoring?.storage?.enabled,
+        enabled: !!conf.enabled
+    };
+}
+function createInstance(conf, instanceId) {
+    return {
+        id: instanceId,
+        instant: dateNow(),
+        name: require$1(getOrCall(conf?.name), 'configuration.name'),
+        version: getOrCall(conf?.version),
+        address: getClientID(), //server side
+        env: require$1(getOrCall(conf?.env), 'env'),
+        os: detectOs(),
+        re: detectBrowser(),
+        user: undefined, // cannot get user
+        type: "CLIENT",
+        collector: "inspect-ng-collector-1.3.2-beta.1",
+        resource: { maxHeap: (('memory' in performance) && performance.memory.jsHeapSizeLimit / (1024 * 1024)) || undefined },
+        additionalProperties: conf?.additionalProperties?.(),
+        configuration: adaptedConfig(conf)
+    };
+}
+function getClientID() {
+    let cid = localStorage.getItem("jarvis.inspect.cid");
+    if (!cid) {
+        localStorage.setItem("jarvis.inspect.cid", cid = crypto.randomUUID());
     }
-    static get instance() {
-        if (!ContextManager._instance) {
-            console.warn("[Inspect-ng-collector] Error while initializing ContextManager");
+    return cid;
+}
+function detectOs() {
+    try {
+        let versionMatch, version;
+        const agent = globalThis.navigator.userAgent.toLowerCase(); //TODO see also  https://developer.mozilla.org/en-US/docs/Web/API/Navigator/userAgentData
+        switch (true) {
+            case (/windows/.test(agent)):
+                versionMatch = /windows nt (\d+\.\d+)/.exec(agent);
+                version = versionMatch ? versionMatch[1] : '?';
+                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] : '?';
+                return `MacOs ${version}`;
         }
-        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) || [],
-            hostExcludes: conf?.monitoring?.httpRequest?.excludes?.host || [],
-            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: getSessionAddress(), //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)
-        };
+    catch (e) {
+        dispatchReport("detectOs", e);
     }
+    return undefined;
 }
-function getSessionAddress() {
-    let inspectId = localStorage.getItem("inspect-id");
-    if (!inspectId) {
-        inspectId = crypto.randomUUID();
-        localStorage.setItem("inspect-id", inspectId);
+function detectBrowser() {
+    try {
+        const agent = globalThis.navigator.userAgent.toLowerCase();
+        switch (true) {
+            case agent.includes('edg'):
+                return 'Edge';
+            case agent.includes('opr'):
+                return 'Opera';
+            case agent.includes('chrome'):
+                return 'Chrome';
+            case agent.includes('firefox'):
+                return 'Firefox';
+            case agent.includes('safari'):
+                return 'Safari';
+            case agent.includes('msie'):
+                return 'IE';
+        }
     }
-    return inspectId;
-}
-function instanceApiURL(host, path) {
-    return toURL(host, path);
-}
-function sessionApiURL(host, path) {
-    return toURL(host, path);
+    catch (e) {
+        dispatchReport("detectBrowser", e);
+    }
+    return undefined;
 }
-function toURL(host, path) {
-    return host.endsWith(SLASH) || path.startsWith(SLASH) ? host + path : [host, path].join(SLASH);
+function refreshConfig(id, tech) {
+    const uuidRegex = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+    tech.sessionApi = tech.sessionApi.replace(uuidRegex, id);
+    return id;
 }
 
 class SessionManager {
-    constructor() {
-        this.initialized = false;
+    constructor(_techConfig) {
+        this._techConfig = _techConfig;
     }
     static get instance() {
-        if (!SessionManager._instance) {
-            SessionManager._instance = new SessionManager();
-            WIN["inspect-session-manager"] = SessionManager._instance;
-        }
         return SessionManager._instance;
     }
     navigate(url) {
-        this.getCurrentSession(s => {
-            if (s) {
-                this.getCurrentSessionCallBack(cb => cb.end = dateNow());
-                window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { force: !url, traces: this.currentSessionCallBack } }));
-            }
-            this.currentSession = null;
-        });
+        const now = dateNow();
+        this.endSession(now);
         if (url) {
-            let id = crypto.randomUUID();
+            const id = crypto.randomUUID();
             this.currentSession = {
-                '@type': "10",
+                '@type': TRACE_TYPE_MAIN_SESSION,
                 id: id,
-                user: ContextManager.instance.techConfig.user,
-                start: dateNow(),
                 type: "VIEW",
+                user: getOrCall(this._techConfig.user),
+                start: now,
                 location: url,
-                loading: true,
                 requestMask: 0,
             };
-            this.initialized = true;
             this.currentSessionCallBack = {
-                '@type': "11",
+                '@type': TRACE_TYPE_MAIN_SESSION_CALLBACK,
                 id: id,
                 requestMask: 0,
             };
         }
     }
-    updateSession() {
-        this.getCurrentSession(s => {
-            s.name = document.title;
-            s.location = document.URL;
-            if (!ContextManager.instance.techConfig.exclude?.some((e) => e.test(s.location))) {
-                window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: s } }));
-            }
+    endSession(end) {
+        this.getCurrentSessionCallBack(call => {
+            call.end = end;
+            dispatchTraces(call);
         });
+        this.currentSessionCallBack = undefined;
     }
-    getCurrentSession(fn) {
+    updateSession() {
         if (this.currentSession) {
-            return fn(this.currentSession);
+            this.currentSession.name = document.title; // add settimeout
+            this.currentSession.location = document.URL;
+            if (!this._techConfig.exclude?.some((e) => e.test(this.currentSession?.location))) {
+                dispatchTraces(this.currentSession);
+            }
+            this.currentSession = undefined;
+        }
+        else {
+            dispatchReport('updateSession', 'no active session');
         }
-        this.initialized && window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createReport("no active session found ") } }));
-        return undefined;
     }
     getCurrentSessionCallBack(fn) {
         if (this.currentSessionCallBack) {
             return fn(this.currentSessionCallBack);
         }
-        window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createReport("no active session found ") } }));
+        dispatchReport('getCurrentSessionCallBack', 'no active session');
         return undefined;
     }
     currentSessionID() {
-        return this.getCurrentSession(s => s.id);
-    }
-    updateMask(requestMask) {
-        return this.getCurrentSessionCallBack(s => {
-            let before = s.requestMask;
-            s.requestMask |= requestMask;
-            return s.requestMask !== before;
+        return this.getCurrentSessionCallBack(s => s.id);
+    }
+    initRestRequest(mask) {
+        const req = this.getCurrentSessionCallBack(s => {
+            if ((s.requestMask & mask) !== mask) {
+                s.requestMask |= mask;
+                dispatchTraces({
+                    "@type": TRACE_TYPE_SESSION_MASK_UPDATE,
+                    id: s.id,
+                    main: true,
+                    mask: s.requestMask
+                });
+            }
+            return { sessionId: s.id };
         });
+        return req || {};
+    }
+    initUserAction() {
+        const req = this.getCurrentSessionCallBack(s => ({ sessionId: s.id }));
+        return req || {};
     }
     addException(exception) {
         this.getCurrentSessionCallBack(s => s.exception = exception);
     }
+    info(message) {
+        this.log("INFO", message);
+    }
+    warn(message) {
+        this.log("WARN", message);
+    }
+    error(message) {
+        this.log("ERROR", message);
+    }
+    log(level, message) {
+        if (message) {
+            this.getCurrentSessionCallBack(s => dispatchLog(level, message, s.id));
+        }
+    }
+}
+function sessionlogger() {
+    return SessionManager.instance;
+}
+function sessionManager(tech) {
+    SessionManager._instance = new SessionManager(tech);
+    WIN["inspect-session-manager"] = SessionManager._instance;
 }
 
+const TRACE_HEADER = 'x-tracert';
 class RestRequestMonitor {
-    constructor(restRequest) {
-        const start = dateNow();
-        const url = toHref(restRequest.urlWithParams);
+    constructor() {
+        this.start = dateNow();
+        this.id = crypto.randomUUID();
+    }
+    preProcess(restRequest) {
+        const url = new URL(restRequest.urlWithParams, window.location.origin); //TDO check & remove toHref(restRequest.urlWithParams)
         const auth_user = extractAuthSchemeAnduser(restRequest.headers);
-        this.restRequest = {
-            "@type": "120",
-            id: crypto.randomUUID(),
+        dispatchTraces({ ...SessionManager.instance.initRestRequest(RequestMask.REST),
+            "@type": TRACE_TYPE_REST_REQUEST,
+            id: this.id,
             method: restRequest.method,
             protocol: url.protocol.slice(0, -1),
-            host: exctractHost(url.host),
-            port: +url.port || -1,
+            host: url.hostname,
+            port: url.port ? Number(url.port) : 0,
             path: url.pathname,
             query: url.search.slice(1, url.search.length),
             contentType: restRequest.responseType,
             authScheme: auth_user.authScheme,
             user: auth_user.user,
             dataSize: sizeOf(restRequest.body),
-            start: start,
-            sessionId: SessionManager.instance.currentSessionID()
-        };
-        this.restRequestCallBack = {
-            "@type": "121",
-            id: this.restRequest.id,
+            start: this.start,
+        });
+    }
+    postProcess(response, error) {
+        const end = dateNow();
+        const callback = {
+            "@type": TRACE_TYPE_REST_REQUEST_CALLBACK,
+            id: this.id,
             dataSize: -1,
-            linked: false
+            linked: false,
+            end: end
         };
-        if (SessionManager.instance.currentSessionID() != null) {
-            let doUpdateMask = SessionManager.instance.updateMask(RequestMask.REST);
-            doUpdateMask && window.dispatchEvent(new CustomEvent(DISPATCH, { detail: {
-                    traces: {
-                        "@type": "03",
-                        id: SessionManager.instance.currentSessionID(),
-                        main: true,
-                        mask: SessionManager.instance.getCurrentSessionCallBack(s => s.requestMask)
-                    }
-                }
-            }));
-        }
-    }
-    postProcess(event, error) {
-        let status = 0, exception = null;
-        if (event) {
-            status = +event.status;
-            this.restRequestCallBack.dataSize = sizeOf(event.body);
-            this.restRequestCallBack.linked = this.assertSessionID(this.restRequest.id, event.headers);
-        }
+        let status = 0, exception;
+        // HttpResponseBase couvre à la fois HttpResponse (succès) et HttpErrorResponse (erreur HTTP)
+        if (response) {
+            status = response.status;
+            callback.dataSize = response instanceof HttpResponse ? sizeOf(response.body) : -1;
+            callback.contentType = extractContentType(response.headers);
+            callback.linked = assertSessionID(this.id, response.headers);
+        }
+        // Erreur réseau/annulation
         if (error) {
-            this.restRequestCallBack.linked = error?.headers && this.assertSessionID(this.restRequest.id, error.headers);
-            status = +error.status;
+            status = error.status || 0;
             exception = {
                 type: error.name,
                 message: error.error && error.status ? JSON.stringify(error.error) : error.message
             };
-            this.restRequestCallBack.bodyContent = error instanceof HttpErrorResponse ? JSON.stringify(error.error) : undefined;
-            this.restRequestCallBack.dataSize = sizeOf(error.error);
-        }
-        this.restRequestCallBack.contentType = extractContentType(event?.headers);
-        this.restRequestCallBack.end = dateNow();
-        this.restRequestCallBack.status = +status;
-        let stage = {
-            "@type": "220",
+            callback.bodyContent = JSON.stringify(error.error);
+            callback.dataSize = sizeOf(error.error);
+            callback.contentType = extractContentType(error.headers);
+            callback.linked = assertSessionID(this.id, error.headers);
+        }
+        callback.status = status;
+        dispatchTraces(callback, {
+            "@type": TRACE_TYPE_HTTP_REQUEST_STAGE,
             name: "PROCESS",
-            start: this.restRequest.start, //  use request
-            end: dateNow(),
+            start: this.start, //  use request
+            end: end,
             order: 0,
             exception: exception,
-            requestId: this.restRequestCallBack.id
-        };
-        window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: this.restRequestCallBack } }));
-        window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: stage } }));
-    }
-    assertSessionID(id, headers) {
-        if (headers?.has('x-tracert')) {
-            if (id == headers.get('x-tracert')) {
-                return true;
-            }
-        }
-        return false;
+            requestId: this.id
+        });
     }
 }
-function toHref(url) {
-    const href = document.createElement('a');
-    href.setAttribute('href', url);
-    return href;
-}
-function exctractHost(path) {
-    const portregex = /:\d+/;
-    return path.replace(portregex, '');
+function assertSessionID(id, headers) {
+    return headers?.get(TRACE_HEADER) == id;
 }
 function extractAuthSchemeAnduser(headers) {
-    let auth_user = {
-        user: undefined,
-        authScheme: undefined
+    const scheme = headers.has('authorization') && headers.get('authorization').match(/^(\w+) /)?.at(1);
+    return {
+        authScheme: scheme,
+        user: scheme ?? extractUser(scheme, headers.get('authorization').split(" ")[1])
     };
+}
+function extractUser(scheme, authorization) {
     try {
-        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];
-                break;
+        switch (scheme) {
+            case "Basic": return atob(authorization).toString().split(':')[0];
             case "Bearer": {
-                const parts = headers.get('authorization').split(" ")[1].split('.');
+                const parts = authorization.split('.');
                 if (parts.length == 3) {
-                    auth_user.user = JSON.parse(atob(parts[1]).toString()).sub;
+                    return JSON.parse(atob(parts[1]).toString()).sub; //TODO regex .match(/^\w+\.\w+\.(\w+) /)?.at(1)
                 }
+                dispatchReport('extractUser', `Invalid Bearer token format: expected 3 parts, got ${parts.length}`);
+                return undefined;
+            }
+            default: {
+                dispatchReport('extractUser', `Unknown auth scheme: ${scheme}`);
             }
         }
     }
-    catch (err) {
-        createReport(JSON.stringify(err));
+    catch (e) {
+        dispatchReport('extractUser', e);
     }
-    return auth_user;
+    return undefined;
 }
 function extractContentType(headers) {
     try {
@@ -432,56 +431,71 @@ function extractContentType(headers) {
         }
     }
     catch (err) {
-        createReport(JSON.stringify(err));
+        dispatchReport('extractContentType', err);
     }
     return undefined;
 }
 function sizeOf(body) {
-    return body ? JSON.stringify(body).length : 0;
+    if (body) {
+        try {
+            return new Blob([JSON.stringify(body)]).size;
+        }
+        catch (e) {
+            dispatchReport('sizeOf', e);
+        }
+    }
+    return -1;
 }
 
+const COLLECTOR_CONFIG$1 = new InjectionToken('COLLECTOR_CONFIG');
 class HttpInterceptorService {
-    constructor() { }
+    constructor(techConfig) {
+        this.techConfig = techConfig;
+    }
     intercept(req, next) {
-        let restRequestMonitor = new RestRequestMonitor(req);
-        let e;
-        window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: restRequestMonitor.restRequest } }));
+        const monitor = new RestRequestMonitor();
+        monitor.preProcess(req);
         const host = new URL(req.url, window.location.origin).host;
-        if (!ContextManager.instance.techConfig.hostExcludes?.some((e) => e == host)) {
-            req = req.clone({ headers: req.headers.set('x-tracert', restRequestMonitor.restRequest.id) });
+        if (!this.techConfig.hostExcludes?.some((e) => e == host)) { // exclude les hôtes qui ne permet pas la modification des headers
+            req = req.clone({ headers: req.headers.set(TRACE_HEADER, monitor.id) });
         }
+        let response = null;
+        let error = null;
         return next.handle(req).pipe(tap({
             next: (event) => {
                 if (event instanceof HttpResponse) {
-                    e = event;
+                    response = event;
                 }
+                //todo  autres types d'événements (UploadProgress, DownloadProgress, etc.) ignorés pour les traces
             },
-            error: (error) => {
-                e = error;
-            },
-            unsubscribe: () => {
-                e = { status: 0,
-                    name: "Unsubscribed",
-                    message: "The request was cancelled before completion."
-                };
+            error: (err) => {
+                error = err;
             }
         }), finalize(() => {
-            e instanceof HttpResponse ? restRequestMonitor.postProcess(e, null) : restRequestMonitor.postProcess(null, e ?? {
-                status: 0,
-                name: "IOException",
-                message: "The remote server is unavailable.",
-            });
+            // Si pas de réponse et pas d'erreur capturé, la requête a été annulée
+            if (!response && !error) {
+                error = new HttpErrorResponse({
+                    error: 'The request was cancelled before completion',
+                    status: 0,
+                    statusText: 'Cancelled',
+                    url: req.url
+                });
+            }
+            monitor.postProcess(response, error);
         }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: HttpInterceptorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: HttpInterceptorService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: HttpInterceptorService, deps: [{ token: COLLECTOR_CONFIG$1 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: HttpInterceptorService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: HttpInterceptorService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: HttpInterceptorService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [COLLECTOR_CONFIG$1]
+                }] }] });
 
-class GlobalErrorHandlerService {
+class GlobalErrorHandler {
     handleError(error) {
         try {
             SessionManager.instance.addException({
@@ -490,208 +504,181 @@ class GlobalErrorHandlerService {
             });
         }
         catch (e) {
-            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createReport("Erreur dans GlobalErrorHandlerService: " + JSON.stringify(e)) } }));
+            dispatchReport("GlobalErrorHandlerService.handleError", e);
         }
         throw error;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: GlobalErrorHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: GlobalErrorHandlerService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: GlobalErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: GlobalErrorHandler, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: GlobalErrorHandlerService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: GlobalErrorHandler, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
-function eventTraceScheduledDispatcher() {
-    return EventTraceScheduledDispatcherService._instance = new EventTraceScheduledDispatcherService();
-}
+const EMPTY_ARRAY = Object.freeze([]);
 class EventTraceScheduledDispatcherService {
-    constructor() {
-        this.traceQueue = new Set();
-        this.sessionSendAttempts = 0;
-        this.sendSessionfinished = true;
-        this.instanceSaved = false;
-        interval(ContextManager.instance.techConfig.interval)
+    constructor(_techConfig) {
+        this._techConfig = _techConfig;
+        this.traceQueue = [];
+        this.dispatchAttempts = 0;
+        this.dispatching = false;
+        this.instanceDispatched = false;
+        this.wasDestroyed = false;
+        this.subscription = interval(_techConfig.interval)
             .pipe(startWith(0))
             .pipe(tap$1(() => {
-            if (this.sendSessionfinished) {
-                this.sendSessionfinished = false;
-                window.dispatchEvent(new CustomEvent(PRE_DISPATCH));
-                this.Dispatch()
-                    .catch(err => { })
-                    .finally(() => { this.sendSessionfinished = true; });
+            if (!this.dispatching && !this.wasDestroyed && this.instance) {
+                this.dispatching = true;
+                dispatchExport();
+                this.dispatch()
+                    .then(arr => this.revertQueueSize(arr))
+                    .catch(err => dispatchReport('EventTraceScheduledDispatcher.dispatch', err))
+                    .finally(() => { this.dispatching = false; });
             }
         }))
             .subscribe();
-        window.addEventListener(DISPATCH, (e) => {
-            e.detail.traces && this.addtoQueue(e.detail.traces);
-            if (e.detail.force) {
-                this.sendSessions(true);
-                this.onDestroy();
-            }
-        });
+        addTraceListener(e => this.appendTrace(e.detail.traces));
+        addShutdownListener(e => this.destroy());
+    }
+    appendTrace(events) {
+        if (!this.wasDestroyed) {
+            events?.forEach(event => this.traceQueue.push(event));
+        }
+    }
+    trace(instance) {
+        this.instance = instance;
     }
-    Dispatch() {
-        if (this.instanceSaved) {
-            return this.sendSessions();
+    dispatch() {
+        if (this.instanceDispatched) {
+            return this.dispatchTraces();
         }
-        return this.postInstanceEnv().then((ok) => {
+        return this.dispatchInstance().then(ok => {
             if (ok) {
-                return this.sendSessions();
+                this.instanceDispatched = true;
+                return this.dispatchTraces();
             }
-            this.sessionSendAttempts % 5 == 0 && console.warn(`Error while attempting to send Environement instance, attempts ${this.sessionSendAttempts}`);
+            console.warn(`Error while attempting to send Environement instance, attempts ${this.dispatchAttempts}`);
             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));
+    dispatchTraces(destroy) {
+        if (this.traceQueue.length === 0) {
+            return Promise.resolve(EMPTY_ARRAY);
         }
-        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 {
+        let uri = this._techConfig.sessionApi + "?attempts=" + ++this.dispatchAttempts;
+        if (destroy) {
+            uri += "&end=" + new Date().toISOString();
+        }
+        const traces = [...this.traceQueue];
+        this.traceQueue.length = 0;
+        return fetch(uri, {
             method: 'PUT',
             headers: { 'Content-Type': 'application/json' },
             mode: 'cors',
             keepalive: true,
-            body: JSON.stringify(Array.from(sessionList))
-        };
+            body: JSON.stringify(traces)
+        })
+            .then(res => {
+            if (res.ok) {
+                this.dispatchAttempts = 0;
+                return EMPTY_ARRAY;
+            }
+            console.warn(`Error while attempting to send sessions, attempts: ${this.dispatchAttempts}`);
+            if (res.status >= 400 && res.status < 500) {
+                return traces; //retry on bad request !?
+            }
+            return res.json()
+                .then(body => body?.retry ? traces : EMPTY_ARRAY)
+                .catch(() => EMPTY_ARRAY);
+        })
+            .catch(() => {
+            console.warn(`Error while attempting to send sessions, attempts: ${this.dispatchAttempts}`); //no cnx !
+            return traces;
+        });
     }
-    postInstanceEnv() {
-        this.sessionSendAttempts++;
-        return fetch(ContextManager.instance.techConfig.instanceApi, {
+    dispatchInstance() {
+        this.dispatchAttempts++;
+        return fetch(this._techConfig.instanceApi, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             mode: 'cors',
             keepalive: true,
-            body: JSON.stringify(ContextManager.instance.instanceEnv)
+            body: JSON.stringify(this.instance)
         })
             .then(res => res.ok ? res.text().then(id => {
-            this.sessionSendAttempts = 0;
-            return this.instanceSaved = true;
+            this.dispatchAttempts = 0;
+            return 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);
+    revertQueueSize(traces) {
+        if (!this.wasDestroyed) {
+            this.traceQueue.unshift(...traces);
+            if (this.traceQueue.length > this._techConfig.queueCapacity) {
+                this.traceQueue.splice(this._techConfig.queueCapacity);
             }
         }
-        catch (e) {
-            this.addtoQueue(createReport(String(e)));
-        }
     }
-    onDestroy() {
-        this.traceQueue.clear();
-        this.sendSessionfinished = true;
-        this.instanceSaved = false;
-        this.sessionSendAttempts = 0;
+    destroy() {
+        this.subscription?.unsubscribe();
+        this.wasDestroyed = true;
+        dispatchExport(); //last metric ??
+        this.dispatchTraces(true);
     }
 }
-
-function routeHandler(event) {
-    if (event instanceof NavigationStart) {
-        SessionManager.instance.navigate(event.url);
-    }
-    if (event instanceof NavigationEnd || event instanceof NavigationCancel) {
-        setTimeout(() => SessionManager.instance.updateSession(), 0);
-    }
-}
-function windowUnloadHandler(event) {
-    SessionManager.instance.navigate();
-}
-function bfCacheHandler(event) {
-    if (event.persisted) { // if the page was restored from bfcache
-        ContextManager.init(NgCollectorModule.configuration);
-        SessionManager.instance.navigate(document.URL);
-        setTimeout(() => SessionManager.instance.updateSession(), 0);
-    }
+function eventTraceScheduledDispatcher(tech) {
+    return EventTraceScheduledDispatcherService._instance = new EventTraceScheduledDispatcherService(tech);
 }
 
-function machineRessourceUsageHandler(event) {
-    window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: getMemoryInfo() } }));
-}
-function getMemoryInfo() {
+const eventHandlers = {
+    'click': (target) => lookUpChild(target, 1),
+};
+function initUserActionMonitor() {
     try {
-        const memory = performance.memory;
-        return {
-            '@type': '01',
-            instant: dateNow(),
-            usedHeap: memory.usedJSHeapSize / (1024 * 1024),
-            commitedHeap: memory.totalJSHeapSize / (1024 * 1024),
-        };
+        const body = window.document.body;
+        body.addEventListener('click', globalHandler, true);
+        body.addEventListener('change', globalHandler, true);
+        body.addEventListener('scrollend', globalHandler, true);
+        body.addEventListener('dragend', globalHandler, true);
+        window.document.addEventListener('DOMContentLoaded', globalHandler, true);
     }
     catch (e) {
-        createReport(JSON.stringify(e));
+        dispatchReport("initUserActionMonitor", e);
     }
-    return null;
 }
-
-function routerEventsListener(router) {
-    router.events.subscribe(routeHandler);
-}
-function beforeUnloadListener() {
-    window.addEventListener(BEFOREUNLOAD, windowUnloadHandler);
+function globalHandler(event) {
+    const target = event.target;
+    const eventType = event.type;
+    try {
+        if (eventHandlers.hasOwnProperty(eventType) && !eventHandlers[eventType](target)) {
+            return;
+        }
+        addActionUser(eventType, target);
+    }
+    catch (err) {
+        dispatchReport("UserACTION.globalHandler", err);
+    }
 }
-function beforeDispatchListener() {
-    if (ContextManager.instance.techConfig.resources && 'memory' in performance) {
-        window.addEventListener(PRE_DISPATCH, machineRessourceUsageHandler);
+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 bfCacheListener() {
-    window.addEventListener('pageshow', bfCacheHandler);
+function addActionUser(eventType, target) {
+    dispatchTraces({
+        ...SessionManager.instance.initUserAction(),
+        '@type': TRACE_TYPE_USER_ACTION,
+        type: eventType,
+        instant: dateNow(),
+        name: extractName(target),
+        nodeName: target.tagName?.toLowerCase()
+    });
 }
-
-const genericMap = [
-    t => t.getAttribute('placeholder'),
-    t => t.getAttribute('title'),
-    t => t.innerText,
-    t => t.getAttribute('name'),
-    t => t.getAttribute('id'),
-];
-const MAP = {
-    'img': [
-        t => t.getAttribute('alt'),
-        t => t.getAttribute('src'),
-    ],
-    'input': [
-        t => t.getAttribute('name'),
-    ],
-    'a': [
-        t => t.getAttribute('href'),
-    ],
-    'label': [
-        t => t.getAttribute('for'),
-    ],
-};
 function getFirst(c, t) {
     for (const o of c) {
         let r = o(t)?.trim();
@@ -718,378 +705,202 @@ function extractName(t) {
     }
     return null;
 }
-
-let eventHandlers = {
-    'click': (target) => lookUpChild(target, 1),
+const genericMap = [
+    t => t.getAttribute('placeholder'),
+    t => t.getAttribute('title'),
+    t => t.innerText,
+    t => t.getAttribute('name'),
+    t => t.getAttribute('id'),
+];
+const MAP = {
+    'img': [
+        t => t.getAttribute('alt'),
+        t => t.getAttribute('src'),
+    ],
+    'input': [
+        t => t.getAttribute('name'),
+    ],
+    'a': [
+        t => t.getAttribute('href'),
+    ],
+    'label': [
+        t => t.getAttribute('for'),
+    ],
 };
-function analyticsEventsListener() {
-    if (ContextManager.instance.techConfig.analytics) {
-        try {
-            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 (e) {
-            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createReport("Error while subscribing to analytics user events: " + JSON.stringify(e)) } }));
-        }
-    }
-}
-function globalHandler(event) {
-    let target = event.target;
-    let eventType = event.type;
+
+function initNavigationMonitor(router) {
     try {
-        if (eventHandlers.hasOwnProperty(eventType) && !eventHandlers[eventType](target)) {
-            return;
-        }
-        addActionUser(eventType, target);
+        router.events.subscribe(routeHandler);
+        window.addEventListener('pageshow', bfCacheHandler);
+        window.addEventListener("beforeunload", windowUnloadHandler);
     }
-    catch (err) {
-        console.warn(err);
+    catch (e) {
+        dispatchReport('initNavigationMonitor', e);
     }
 }
-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);
+function routeHandler(event) {
+    if (event instanceof NavigationStart) {
+        SessionManager.instance.navigate(event.url);
+    }
+    if (event instanceof NavigationEnd || event instanceof NavigationCancel) {
+        setTimeout(() => SessionManager.instance.updateSession(), 0);
     }
-    return true;
-}
-function addActionUser(eventType, target) {
-    const ua = {
-        '@type': "300",
-        type: eventType,
-        start: dateNow(),
-        name: extractName(target),
-        nodeName: target.tagName?.toLowerCase(),
-        sessionId: SessionManager.instance?.currentSessionID()
-    };
-    window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: ua } }));
 }
-
-function eventTraceDebugger() {
-    EventTraceDebugger._instance = new EventTraceDebugger();
+function windowUnloadHandler(event) {
+    SessionManager.instance.navigate();
+    dispatchShutown();
 }
-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)) } }));
-        }
+function bfCacheHandler(event) {
+    if (event.persisted) { // if the page was restored from bfcache
+        dispatchReload();
+        SessionManager.instance.navigate(document.URL);
+        setTimeout(() => SessionManager.instance.updateSession(), 0);
     }
-    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;
-            }
+}
+
+function initResourceUsageMonitor() {
+    try {
+        if ('memory' in performance) {
+            addExportListener(ressourceUsageHandler);
         }
     }
-    static init() {
-        return EventTraceDebugger._instance = new EventTraceDebugger();
+    catch (e) {
+        dispatchReport('initResourceUsageMonitor', e);
     }
-    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);
-        s += '\n';
-        this.httpRequestStages.filter((s) => s.requestId == rest.id).forEach((stage) => {
-            s += this.prettyHttpRequestStageFormat(stage);
+}
+function ressourceUsageHandler() {
+    try {
+        const memory = performance.memory;
+        dispatchTraces({
+            '@type': TRACE_TYPE_RESOURCE_USAGE,
+            instant: dateNow(),
+            usedHeap: memory.usedJSHeapSize / (1024 * 1024),
+            commitedHeap: memory.totalJSHeapSize / (1024 * 1024),
         });
-        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 = [];
+    catch (e) {
+        dispatchReport('ressourceUsageHandler', e);
     }
 }
 
+const COLLECTOR_CONFIG = new InjectionToken('COLLECTOR_CONFIG');
 class NgCollectorModule {
-    static { this.forRootCalled = false; }
     static forRoot(configuration) {
-        console.log("forRootCalled");
-        this.configuration = configuration;
-        if (configuration?.enabled && !NgCollectorModule.forRootCalled) {
-            NgCollectorModule.forRootCalled = true;
+        const providers = [];
+        if (configuration?.enabled) {
             try {
-                ContextManager.init(configuration);
-                return {
-                    ngModule: NgCollectorModule,
-                    providers: [
-                        //provideAppInitializer(initializeEvents),
-                        { provide: APP_INITIALIZER, useFactory: initializeEvents, deps: [Router], multi: true },
-                        { provide: HTTP_INTERCEPTORS, useClass: HttpInterceptorService, multi: true },
-                        { provide: ErrorHandler, useClass: GlobalErrorHandlerService }
-                    ]
-                };
+                let config = initializeCollector(configuration);
+                providers.push({ provide: COLLECTOR_CONFIG, useValue: config }, { provide: APP_INITIALIZER, useFactory: initializeEventsFactory, deps: [COLLECTOR_CONFIG, Router], multi: true }, { provide: HTTP_INTERCEPTORS, useClass: HttpInterceptorService, deps: [COLLECTOR_CONFIG], multi: true }, { provide: ErrorHandler, useClass: GlobalErrorHandler });
             }
             catch (e) {
                 console.warn(`invalid Configuration, Ng-collector is disabled because of this ${e.message}`);
             }
         }
-        return {
-            ngModule: NgCollectorModule
-        };
+        return { ngModule: NgCollectorModule, providers: providers };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NgCollectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.17", ngImport: i0, type: NgCollectorModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NgCollectorModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: NgCollectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.20", ngImport: i0, type: NgCollectorModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: NgCollectorModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NgCollectorModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: NgCollectorModule, decorators: [{
             type: NgModule
         }] });
-function initializeEvents(router) {
+function initializeEventsFactory(config, router) {
     return () => {
-        ContextManager.init(NgCollectorModule.configuration);
-        eventTraceScheduledDispatcher();
-        eventTraceDebugger();
-        analyticsEventsListener();
+        if (config.tech.analytics) {
+            initUserActionMonitor();
+        }
+        if (config.tech.resources) {
+            initResourceUsageMonitor();
+        }
+        initNavigationMonitor(router);
         //storageEventListener();
-        beforeDispatchListener();
-        beforeUnloadListener();
-        routerEventsListener(router);
-        bfCacheListener();
+        //eventTraceDebugger
+        addReloadListener(e => {
+            reloadCollector(config);
+        });
     };
 }
+function initializeCollector(config) {
+    const id = crypto.randomUUID();
+    const tech = validateAndGetConfig(config, id);
+    const dispatch = eventTraceScheduledDispatcher(tech);
+    const instance = createInstance(config, id);
+    dispatch.trace(instance);
+    sessionManager(tech);
+    return { tech: tech, instance: instance };
+}
+function reloadCollector(config) {
+    const id = crypto.randomUUID();
+    refreshConfig(id, config.tech);
+    const dispatch = eventTraceScheduledDispatcher(config.tech);
+    config.instance.id = id;
+    dispatch.trace(config.instance);
+    sessionManager(config.tech);
+}
+
+class LocalRequestMonitor {
+    constructor() {
+        this.start = dateNow();
+        this.id = crypto.randomUUID();
+    }
+    preProcess(propertyKey, target) {
+        dispatchTraces({
+            ...WIN["inspect-session-manager"]?.initRestRequest(RequestMask.LOCAL),
+            "@type": TRACE_TYPE_LOCAL_REQUEST,
+            id: this.id,
+            name: propertyKey,
+            location: target.constructor.name,
+            user: WIN["inspect-session-manager"]?.currentSession?.user, //bad access
+            start: this.start
+        });
+    }
+    postProcess(exception) {
+        dispatchTraces({
+            "@type": TRACE_TYPE_LOCAL_REQUEST_CALLBACK,
+            id: this.id,
+            exception: exception,
+            end: dateNow()
+        });
+    }
+}
 
 function TraceableStage() {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = function (...args) {
+            const monitor = new LocalRequestMonitor();
             let exception;
-            let start, end;
-            start = Date.now();
             try {
+                monitor.preProcess(propertyKey, target);
                 return originalMethod.apply(this, args);
             }
             catch (e) {
-                let type = null, message = null;
-                if (e) {
-                    if (typeof e === "string") {
-                        message = e;
-                    }
-                    else if (e instanceof Error) {
-                        type = e.name;
-                        message = e.message;
-                    }
-                    else {
-                        message = JSON.stringify(e);
-                    }
-                }
-                exception = {
-                    type: type,
-                    message: message
-                };
+                exception = resolveException(e);
                 throw e;
             }
             finally {
-                end = Date.now();
-                let id = crypto.randomUUID();
-                if (WIN["inspect-session-manager"]?.currentSessionID() != null) {
-                    let doUpdateMask = WIN["inspect-session-manager"]?.updateMask(RequestMask.LOCAL);
-                    doUpdateMask && window.dispatchEvent(new CustomEvent(DISPATCH, { detail: {
-                            traces: {
-                                "@type": "03",
-                                id: WIN["inspect-session-manager"]?.currentSessionID(),
-                                main: true,
-                                mask: WIN["inspect-session-manager"]?.getCurrentSessionCallBack((s) => s.requestMask)
-                            }
-                        }
-                    }));
-                }
-                window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: {
-                            "@type": "110",
-                            id: id,
-                            name: propertyKey,
-                            location: target.constructor.name,
-                            user: WIN["inspect-session-manager"]?.currentSession?.user,
-                            start: start,
-                            sessionId: WIN["inspect-session-manager"]?.currentSession?.id
-                        }
-                    }
-                }));
-                window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: {
-                            "@type": "111",
-                            id: id,
-                            exception: exception,
-                            end: end
-                        }
-                    }
-                }));
+                monitor.postProcess(exception);
             }
         };
         return descriptor;
     };
 }
-
-class LogService {
-    static info(message) {
-        if (message) {
-            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createLogEntry("INFO", message, SessionManager.instance?.currentSessionID()) } }));
+function resolveException(e) {
+    let type = null, message = null;
+    if (e) {
+        if (typeof e === "string") {
+            message = e;
         }
-    }
-    static warn(message) {
-        if (message) {
-            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createLogEntry("WARN", message, SessionManager.instance?.currentSessionID()) } }));
+        else if (e instanceof Error) {
+            type = e.name;
+            message = e.message;
         }
-    }
-    static error(message) {
-        if (message) {
-            window.dispatchEvent(new CustomEvent(DISPATCH, { detail: { traces: createLogEntry("ERROR", message, SessionManager.instance?.currentSessionID()) } }));
+        else {
+            message = JSON.stringify(e);
         }
     }
+    return { type, message };
 }
 
 /*
@@ -1100,5 +911,5 @@ class LogService {
  * Generated bundle index. Do not edit.
  */
 
-export { LogService, NgCollectorModule, TraceableStage, initializeEvents };
+export { NgCollectorModule, TraceableStage, initializeCollector, initializeEventsFactory, reloadCollector, resolveException, sessionlogger };
 //# sourceMappingURL=oneteme-inspect-ng-collector.mjs.map