@quanticdigit/web-logging 1.0.3

package/LICENSE.txt

@@ -0,0 +1,47 @@
+COMMERCIAL SOFTWARE LICENSE AGREEMENT
+Quantic Digit S.R.L. — Restricted Use License
+Version 1.0 — © 2025 Quantic Digit S.R.L. All rights reserved.
+
+IMPORTANT – READ CAREFULLY:
+This Software (the “Software”) is provided under license, not sold.  
+By installing, copying or using the Software, you agree to the following terms.
+
+1. GRANT OF LICENSE
+Quantic Digit S.R.L. (“the Author”) grants you a non-exclusive, non-transferable license to use the Software exclusively for:
+- personal learning and experimentation,
+- educational or training activities,
+- software development, prototyping, or testing not intended for commercial release.
+
+2. PROHIBITED USES
+Unless expressly authorized in writing by Quantic Digit S.R.L., it is strictly forbidden to:
+- use the Software in any commercial activity;
+- integrate the Software into products or services intended for end customers;
+- deploy or distribute the Software within a company, organization, or enterprise environment;
+- use the Software in applications, systems or processes with any revenue, profit, or commercial purpose;
+- redistribute, sublicense, sell, rent, lease, or otherwise transfer the Software to third parties.
+
+“Commercial use” includes, but is not limited to:
+- internal business use by companies, organizations or professionals,
+- inclusion in paid services or products,
+- use within customer projects, consultancy, or software delivered to clients,
+- any use that yields direct or indirect economic advantage.
+
+3. OWNERSHIP
+The Software is licensed, not sold.  
+All intellectual property rights remain the sole property of Quantic Digit S.R.L.
+
+4. WARRANTY DISCLAIMER
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT ANY WARRANTY OF ANY KIND.  
+The Author disclaims all implied warranties, including merchantability, fitness for a particular purpose and non-infringement.
+
+5. LIMITATION OF LIABILITY
+In no event shall Quantic Digit S.R.L. be liable for any damages, including direct, indirect, incidental, special or consequential damages arising from the use of the Software.
+
+6. TERMINATION
+Any violation of this License immediately terminates your right to use the Software.  
+Upon termination, you must cease all use and destroy all copies of the Software.
+
+7. GOVERNING LAW
+This Agreement is governed by the laws of Italy, unless otherwise agreed in a written contract with Quantic Digit S.R.L.
+
+© 2025 Quantic Digit S.R.L. — All rights reserved.

package/README.md

@@ -0,0 +1,96 @@
+# @quanticdigit/web-logging
+
+Application log for the client: component lifecycle, every call to the event and action handlers, and
+errors — filtered by a configuration the server decides, delivered by a writer you provide.
+
+The base objects in `@quanticdigit/web-component` and `@quanticdigit/web-errors` are already wired to
+it. Screens get the log without a line of their own.
+
+## Install
+
+```bash
+npm install @quanticdigit/web-logging
+```
+
+Peer dependency: `@angular/core`. Nothing else — this package talks to no backend, because it does
+not know which one you have.
+
+## Turn it on
+
+One provider. That is the whole integration.
+
+```ts
+{ provide: APPLICATION_LOG_WRITER, useClass: MyApplicationLogWriter }
+```
+
+`IApplicationLogWriter` has a single method, `write(entry)`. What it does with the entry is yours:
+queue it, batch it, POST it. It must not throw and must not make anyone wait — the caller is in the
+middle of a screen.
+
+Remove that provider and the log is off everywhere. The base objects look the writer up as optional,
+so without it every log call is a comparison against `null` and nothing else.
+
+## Nothing is logged until you say so
+
+The configuration lives in `sessionStorage` under `log.config`, as an array of
+
+```json
+[{ "path": "app-reports", "startsWith": true, "endsWith": false, "level": "D", "disabled": false }]
+```
+
+A path is matched by the four combinations of the two flags: both means equality, `startsWith` alone
+means prefix, `endsWith` alone means suffix, neither means "contains". Among the rows that match, the
+**most verbose** level wins, so a row at `D` for one screen does not require removing the general one
+at `I`.
+
+**No row that matches means no log.** Not "log everything" — nothing. That is what makes it safe to
+ship the instrumentation long before deciding what to observe, and it is the same rule the server
+applies to its own log configuration.
+
+Levels are the server's one-letter codes, and lower is more severe: `F E W I D T`.
+
+## The path
+
+The root is the component selector, `app-reports`, not the class name — class names are mangled in a
+production build and a log you cannot read is worse than no log. Under it:
+
+| path | what it is |
+| --- | --- |
+| `app-reports.lifecycle` | init and destroy, at `I` |
+| `app-reports.eventHandler.onClickApplyFilters` | a template call, enter/exit at `D`, arguments and result at `T` |
+| `app-reports.actionHandler.load` | the action behind it |
+| `errors.http` | what the error collector received |
+| `errors.unhandled` | what nobody caught, at `F` |
+
+## By hand
+
+For code that is not a component:
+
+```ts
+const logger = new ApplicationLogger(inject(APPLICATION_LOG_WRITER, { optional: true }), 'import-job');
+logger.log('I', 'run', 'started', { file: name });
+```
+
+To instrument an object of your own, `wrapWithLogging(target, logger)` returns a proxy that logs every
+method call. The method still runs on the real object, so private fields keep working and the calls
+the object makes to itself do not go through the proxy again.
+
+## The unhandled ones
+
+`LoggingErrorHandler` replaces Angular's own and adds one line before it:
+
+```ts
+{ provide: ErrorHandler, useClass: LoggingErrorHandler }
+```
+
+An error inside a `subscribe`, a `setTimeout` or a template binding passes through neither the service
+layer nor a handler proxy. This is the only place it shows up.
+
+## The family
+
+`web-utils`, `web-model`, `web-services`, `web-component`, `web-errors` and `web-logging` are released
+together and always share the same version. Install them at the same version.
+
+## License
+
+Commercial. See `LICENSE.txt` in the package.

package/fesm2022/quanticdigit-web-logging.mjs

@@ -0,0 +1,494 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ErrorHandler, inject, Injectable } from '@angular/core';
+
+/**
+ * Ordine di gravita': <b>piu' basso e' piu' grave</b>.
+ *
+ * @remarks
+ * Un livello si scrive quando il suo rango e' minore o uguale a quello configurato: configurare `I`
+ * fa passare `F`, `E`, `W` e `I` e non `D` ne' `T`. E' la stessa tabella che il motore usa lato
+ * server, e le due devono restare uguali o la stessa configurazione produrrebbe due filtri diversi.
+ */
+const APP_LOG_LEVEL_RANK = {
+    F: 1,
+    E: 2,
+    W: 3,
+    I: 4,
+    D: 5,
+    T: 6,
+};
+/**
+ * Il gancio con cui si accende il log.
+ *
+ * @remarks
+ * <b>Opzionale per costruzione.</b> Gli oggetti base lo cercano con `inject(..., { optional: true })`:
+ * dichiarato, si logga; non dichiarato, ogni chiamata di log e' un confronto con `null` e nient'altro.
+ * Togliere una riga di provider spegne il log dell'intera applicazione senza toccare una classe.
+ */
+const APPLICATION_LOG_WRITER = new InjectionToken('QuanticDigit.ApplicationLogWriter');
+/**
+ * Chiave di `sessionStorage` sotto cui vive la configurazione.
+ *
+ * @remarks
+ * `sessionStorage` e non `localStorage`: la configurazione arriva al login ed e' dell'utente e della
+ * sessione: il `sessionStorage.clear()` dell'uscita la porta via senza che nessuno se ne occupi.
+ */
+const APPLICATION_LOG_CONFIG_KEY = 'log.config';
+
+/**
+ * La configurazione del log, letta da `sessionStorage`.
+ *
+ * @remarks
+ * <b>Statica e senza iniezione.</b> La interrogano oggetti che non sono servizi — un proxy su un
+ * gestore di eventi, un logger costruito a mano dentro il costruttore di un component — e che quindi
+ * non hanno un contesto da cui farsi dare nulla.
+ *
+ * <b>La regola e' quella del server.</b> Le stesse quattro combinazioni di `startsWith`/`endsWith` e
+ * la stessa scelta del livello piu' permissivo fra le righe che corrispondono: una configurazione
+ * copiata dal database si comporta qui come si comporterebbe la'. <b>Nessuna riga che corrisponde
+ * significa non loggare</b>, non "loggare tutto": e' cio' che rende innocuo distribuire il codice di
+ * log prima di aver deciso cosa osservare.
+ */
+class ApplicationLogConfig {
+    /** Ultimo JSON letto, per non deserializzarlo a ogni evento. */
+    static lastRaw = null;
+    static lastParsed = [];
+    /** Scrive la configurazione appena ricevuta dal server. */
+    static store(items) {
+        try {
+            sessionStorage.setItem(APPLICATION_LOG_CONFIG_KEY, JSON.stringify(items ?? []));
+        }
+        catch {
+            // Uno storage pieno o negato non e' un problema dell'applicazione: si resta senza log.
+        }
+        ApplicationLogConfig.lastRaw = null;
+    }
+    /** Dimentica la configurazione: da qui in poi non si logga piu' nulla. */
+    static clear() {
+        try {
+            sessionStorage.removeItem(APPLICATION_LOG_CONFIG_KEY);
+        }
+        catch {
+            // Come sopra.
+        }
+        ApplicationLogConfig.lastRaw = null;
+        ApplicationLogConfig.lastParsed = [];
+    }
+    /** Le righe attive, cosi' come sono. */
+    static items() {
+        let raw = null;
+        try {
+            raw = sessionStorage.getItem(APPLICATION_LOG_CONFIG_KEY);
+        }
+        catch {
+            return [];
+        }
+        if (raw == null || raw === '') {
+            ApplicationLogConfig.lastRaw = null;
+            ApplicationLogConfig.lastParsed = [];
+            return [];
+        }
+        if (raw === ApplicationLogConfig.lastRaw) {
+            return ApplicationLogConfig.lastParsed;
+        }
+        let parsed = [];
+        try {
+            const read = JSON.parse(raw);
+            parsed = Array.isArray(read) ? read : [];
+        }
+        catch {
+            parsed = [];
+        }
+        ApplicationLogConfig.lastRaw = raw;
+        ApplicationLogConfig.lastParsed = parsed;
+        return parsed;
+    }
+    /**
+     * Fino a che livello si scrive per questo percorso, oppure `null` se non si scrive affatto.
+     *
+     * @remarks
+     * Fra piu' righe che corrispondono vince la <b>piu' verbosa</b>: chi aggiunge una riga a `D` per
+     * un solo percorso non deve prima togliere quella generale a `I`.
+     */
+    static maxLevelFor(path) {
+        const rows = ApplicationLogConfig.items();
+        let best = null;
+        let bestRank = 0;
+        for (const row of rows) {
+            if (row == null || row.disabled) {
+                continue;
+            }
+            if (!ApplicationLogConfig.matches(path, row)) {
+                continue;
+            }
+            const rank = APP_LOG_LEVEL_RANK[row.level] ?? 0;
+            if (rank > bestRank) {
+                bestRank = rank;
+                best = row.level;
+            }
+        }
+        return best;
+    }
+    /** Vero se il livello richiesto rientra in quello configurato per il percorso. */
+    static isLoggable(level, path) {
+        const max = ApplicationLogConfig.maxLevelFor(path);
+        if (max == null) {
+            return false;
+        }
+        return APP_LOG_LEVEL_RANK[level] <= APP_LOG_LEVEL_RANK[max];
+    }
+    /**
+     * Le quattro combinazioni di confronto.
+     *
+     * @remarks
+     * Entrambi i flag significa uguaglianza esatta, nessuno dei due significa "contiene": e' la
+     * lettura che ne fa `LoggerBase.FilterConfig` lato .NET, e non va reinventata.
+     */
+    static matches(path, row) {
+        const expected = row.path ?? '';
+        if (row.startsWith && row.endsWith) {
+            return path === expected;
+        }
+        if (row.startsWith) {
+            return path.startsWith(expected);
+        }
+        if (row.endsWith) {
+            return path.endsWith(expected);
+        }
+        return path.includes(expected);
+    }
+}
+
+/**
+ * Il punto da cui si logga.
+ *
+ * @remarks
+ * <b>Non e' un servizio.</b> Lo costruiscono gli oggetti base dentro il proprio costruttore, con il
+ * writer che hanno trovato — o non trovato — nel contesto di iniezione. Un logger senza writer non e'
+ * un errore: e' il caso normale di chi non ha acceso il log, e ogni sua chiamata costa un confronto.
+ *
+ * <b>Non lancia mai.</b> Un log che rompe la schermata che stava osservando e' peggio di nessun log:
+ * tutto cio' che sta dentro `log` e' avvolto, writer compreso.
+ */
+class ApplicationLogger {
+    writer;
+    path;
+    constructor(writer, path) {
+        this.writer = writer;
+        this.path = path;
+    }
+    /**
+     * Vero se questo livello verrebbe scritto.
+     *
+     * @remarks
+     * Va chiamata <b>prima</b> di costruire i dati accessori: e' l'unico modo perche' serializzare gli
+     * argomenti di una chiamata costi zero quando il livello `T` non e' acceso.
+     */
+    isLoggable(level, subPath) {
+        if (this.writer == null) {
+            return false;
+        }
+        try {
+            return ApplicationLogConfig.isLoggable(level, this.fullPath(subPath));
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Scrive un evento, se la configurazione lo prevede. */
+    log(level, subPath, message, params, trace) {
+        const writer = this.writer;
+        if (writer == null) {
+            return;
+        }
+        try {
+            const path = this.fullPath(subPath ?? undefined);
+            if (!ApplicationLogConfig.isLoggable(level, path)) {
+                return;
+            }
+            writer.write({
+                level,
+                path,
+                message: message ?? '',
+                params,
+                trace,
+                createdAt: new Date(),
+            });
+        }
+        catch {
+            // Un log che fallisce non ha niente da dire a nessuno.
+        }
+    }
+    /** Un logger sullo stesso writer, un segmento piu' in basso. */
+    child(segment) {
+        return new ApplicationLogger(this.writer, this.fullPath(segment));
+    }
+    fullPath(subPath) {
+        return subPath == null || subPath === '' ? this.path : `${this.path}.${subPath}`;
+    }
+}
+
+/**
+ * Il gestore di ultima istanza di Angular, con una riga di log in piu'.
+ *
+ * @remarks
+ * <b>Copre cio' che nessun altro vede.</b> Il raccoglitore di errori conosce quelli che arrivano dal
+ * livello di servizio; il proxy conosce quelli che nascono dentro un gestore. Un errore in un
+ * `subscribe`, in un `setTimeout` o in un binding del template non passa da nessuno dei due e finisce
+ * qui: e' l'unico punto in cui si scopre che una schermata si e' rotta senza dirlo.
+ *
+ * Livello `F` e percorso `errors.unhandled`: cio' che arriva qui non e' stato gestito da nessuno, per
+ * definizione.
+ *
+ * Si registra come si registra qualsiasi `ErrorHandler`, e il comportamento normale di Angular resta
+ * perche' `super.handleError` viene comunque chiamato.
+ */
+class LoggingErrorHandler extends ErrorHandler {
+    logger = new ApplicationLogger(inject(APPLICATION_LOG_WRITER, { optional: true }), 'errors');
+    handleError(error) {
+        try {
+            const asError = error;
+            this.logger.log('F', 'unhandled', asError?.message ?? String(error), undefined, asError?.stack);
+        }
+        catch {
+            // Il gestore di ultima istanza non puo' essere quello che lancia.
+        }
+        super.handleError(error);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.22", ngImport: i0, type: LoggingErrorHandler, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.22", ngImport: i0, type: LoggingErrorHandler });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.22", ngImport: i0, type: LoggingErrorHandler, decorators: [{
+            type: Injectable
+        }] });
+
+/** Profondita' oltre la quale un oggetto diventa una sigla. */
+const DEFAULT_DEPTH = 2;
+/** Caratteri stimati oltre i quali si smette di descrivere. */
+const DEFAULT_BUDGET = 2048;
+/** Lunghezza massima di una stringa descritta per intero. */
+const MAX_TEXT_LENGTH = 512;
+/**
+ * Riduce un valore qualsiasi a qualcosa che si puo' serializzare e mandare via.
+ *
+ * @remarks
+ * <b>Serve perche' gli argomenti veri non sono serializzabili.</b> Un gestore di eventi riceve
+ * l'evento di DevExtreme, che porta con se' il componente, l'elemento del DOM e da li' l'intera
+ * pagina: `JSON.stringify` ci gira in tondo o produce megabyte. Qui quell'oggetto diventa
+ * `{ type: 'Object' }` e la chiamata resta leggibile senza essere pericolosa.
+ *
+ * Tre limiti, tutti volontari: profondita', numero di caratteri, e riconoscimento delle cose che non
+ * vanno descritte (nodi, eventi, funzioni). Chi legge un log vuole sapere <i>che</i> e' stato passato
+ * un evento, non cosa contenga.
+ */
+function safeValue(value, depth = DEFAULT_DEPTH, budget = DEFAULT_BUDGET) {
+    return reduce(value, depth, { left: budget }, new WeakSet());
+}
+function reduce(value, depth, budget, seen) {
+    if (budget.left <= 0) {
+        return '[truncated]';
+    }
+    if (value === null || value === undefined) {
+        return value ?? null;
+    }
+    const kind = typeof value;
+    if (kind === 'string') {
+        const text = value;
+        budget.left -= text.length;
+        return text.length > MAX_TEXT_LENGTH ? `${text.substring(0, MAX_TEXT_LENGTH)}…` : text;
+    }
+    if (kind === 'number' || kind === 'boolean') {
+        budget.left -= 8;
+        return value;
+    }
+    if (kind === 'bigint' || kind === 'symbol') {
+        budget.left -= 8;
+        return String(value);
+    }
+    if (kind === 'function') {
+        budget.left -= 10;
+        return '[function]';
+    }
+    if (value instanceof Date) {
+        budget.left -= 24;
+        return value.toISOString();
+    }
+    if (value instanceof Error) {
+        budget.left -= 32;
+        return { name: value.name, message: value.message };
+    }
+    const target = value;
+    if (seen.has(target)) {
+        return '[circular]';
+    }
+    if (isOpaque(target)) {
+        budget.left -= 16;
+        return { type: typeNameOf(target) };
+    }
+    if (depth <= 0) {
+        budget.left -= 16;
+        return { type: typeNameOf(target) };
+    }
+    seen.add(target);
+    try {
+        if (Array.isArray(value)) {
+            const list = [];
+            for (const item of value) {
+                if (budget.left <= 0) {
+                    list.push('[truncated]');
+                    break;
+                }
+                list.push(reduce(item, depth - 1, budget, seen));
+            }
+            return list;
+        }
+        const result = {};
+        for (const key of Object.keys(target)) {
+            if (budget.left <= 0) {
+                result['…'] = '[truncated]';
+                break;
+            }
+            budget.left -= key.length;
+            result[key] = reduce(target[key], depth - 1, budget, seen);
+        }
+        return result;
+    }
+    catch {
+        return '[unreadable]';
+    }
+    finally {
+        seen.delete(target);
+    }
+}
+/**
+ * Cose che non si descrivono mai: nodi del DOM, eventi, e gli argomenti di DevExtreme.
+ *
+ * @remarks
+ * Gli eventi di DevExtreme non ereditano da `Event`: sono oggetti semplici con `component` ed
+ * `element` dentro, e da li' si arriva a tutto. Si riconoscono dalla forma perche' non c'e' un tipo
+ * da cui dipendere, e questo pacchetto non dipende da DevExtreme.
+ */
+function isOpaque(value) {
+    if (typeof Node !== 'undefined' && value instanceof Node) {
+        return true;
+    }
+    if (typeof Event !== 'undefined' && value instanceof Event) {
+        return true;
+    }
+    const candidate = value;
+    return candidate['component'] !== undefined && candidate['element'] !== undefined;
+}
+function typeNameOf(value) {
+    try {
+        return value.constructor?.name ?? 'Object';
+    }
+    catch {
+        return 'Object';
+    }
+}
+
+/**
+ * Metodi che non si loggano mai.
+ *
+ * @remarks
+ * Sono l'impalcatura: la costruzione degli oggetti base e i ganci del ciclo di vita di Angular, che
+ * il component gia' registra per conto proprio. Loggarli raddoppierebbe le righe senza aggiungere
+ * nulla. Tutto cio' che inizia per `ng` e' escluso per la stessa ragione.
+ */
+const DEFAULT_EXCLUDED = new Set(['constructor', 'init', 'onInit', 'getActionHandler']);
+/**
+ * Avvolge un oggetto perche' ogni sua chiamata di metodo lasci traccia.
+ *
+ * @remarks
+ * <b>E' cio' che rende il log gratuito per chi scrive le schermate.</b> Il gestore di eventi e quello
+ * delle azioni non sanno di essere osservati e non hanno una riga in piu': l'oggetto base li consegna
+ * avvolti, e da quel momento ogni metodo chiamato dal template o dal gestore registra ingresso,
+ * uscita, durata ed eventuale eccezione.
+ *
+ * <b>Il metodo viene invocato sull'oggetto vero</b>, non sul proxy: i campi privati `#` continuano a
+ * funzionare, e le chiamate che l'oggetto fa a se' stesso non riattraversano il proxy. E' voluto —
+ * si vuole la chiamata che arriva da fuori, non la ricorsione interna.
+ *
+ * Senza writer o senza configurazione il costo e' la trap `get` piu' un confronto: nessun oggetto
+ * costruito, nessun argomento serializzato.
+ */
+function wrapWithLogging(target, logger, excluded = DEFAULT_EXCLUDED) {
+    if (target == null) {
+        return target;
+    }
+    const wrappers = new Map();
+    return new Proxy(target, {
+        get(instance, prop) {
+            const value = Reflect.get(instance, prop, instance);
+            if (typeof prop === 'symbol' || typeof value !== 'function' || excluded.has(prop) || prop.startsWith('ng')) {
+                return value;
+            }
+            const cached = wrappers.get(prop);
+            if (cached != null) {
+                return cached;
+            }
+            const original = value;
+            const name = prop;
+            const wrapper = function (...args) {
+                if (!logger.isLoggable('D', name)) {
+                    return original.apply(instance, args);
+                }
+                const detailed = logger.isLoggable('T', name);
+                logger.log('D', name, 'enter', detailed ? { args: args.map((A) => safeValue(A)) } : undefined);
+                const startedAt = now();
+                try {
+                    const result = original.apply(instance, args);
+                    if (result instanceof Promise) {
+                        result.then((resolved) => logger.log('D', name, 'exit', detailed ? { durationMs: now() - startedAt, result: safeValue(resolved) } : { durationMs: now() - startedAt }), (rejection) => logger.log('E', name, 'error', { durationMs: now() - startedAt }, stackOf(rejection)));
+                        return result;
+                    }
+                    logger.log('D', name, 'exit', detailed ? { durationMs: now() - startedAt, result: safeValue(result) } : { durationMs: now() - startedAt });
+                    return result;
+                }
+                catch (error) {
+                    logger.log('E', name, 'error', { durationMs: now() - startedAt }, stackOf(error));
+                    // Il log osserva, non decide: l'eccezione prosegue verso chi la sa gestire.
+                    throw error;
+                }
+            };
+            wrappers.set(prop, wrapper);
+            return wrapper;
+        },
+    });
+}
+function now() {
+    return typeof performance !== 'undefined' && performance.now != null ? performance.now() : Date.now();
+}
+function stackOf(error) {
+    const asError = error;
+    return asError?.stack ?? String(error);
+}
+
+/**
+ * Superficie pubblica di `@quanticdigit/web-logging`.
+ *
+ * Il log applicativo del client: ingresso e uscita dalle schermate, ogni chiamata ai gestori di
+ * eventi e di azioni, e gli errori — tutto filtrato da una configurazione che decide il server e
+ * recapitato da un writer che fornisce il prodotto.
+ *
+ * <b>Due sole cose vanno capite per usarlo.</b>
+ *
+ * 1. **il writer** — si dichiara `APPLICATION_LOG_WRITER` e il log si accende; non dichiararlo lo
+ *    spegne ovunque, perche' gli oggetti base lo cercano come opzionale e senza di lui non fanno
+ *    nulla. Questo pacchetto non parla con nessun backend: non sa quale sia.
+ * 2. **la configurazione** — sta in `sessionStorage` sotto `log.config` e arriva dal server al
+ *    momento del login. Senza righe che corrispondono <b>non si logga</b>: il codice di log puo'
+ *    essere distribuito molto prima di aver deciso cosa osservare, e non costa nulla finche' nessuno
+ *    lo accende.
+ *
+ * Chi usa `@quanticdigit/web-component` e `@quanticdigit/web-errors` non deve fare altro: gli oggetti
+ * base sono gia' agganciati. Il resto di questa superficie serve a chi vuole loggare a mano
+ * (`ApplicationLogger`) o avvolgere oggetti propri (`wrapWithLogging`).
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { APPLICATION_LOG_CONFIG_KEY, APPLICATION_LOG_WRITER, APP_LOG_LEVEL_RANK, ApplicationLogConfig, ApplicationLogger, DEFAULT_EXCLUDED, LoggingErrorHandler, safeValue, wrapWithLogging };
+//# sourceMappingURL=quanticdigit-web-logging.mjs.map

package/fesm2022/quanticdigit-web-logging.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"quanticdigit-web-logging.mjs","sources":["../../../projects/web-logging/src/lib/contracts.ts","../../../projects/web-logging/src/lib/application-log-config.ts","../../../projects/web-logging/src/lib/application-logger.ts","../../../projects/web-logging/src/lib/logging-error-handler.ts","../../../projects/web-logging/src/lib/safe-value.ts","../../../projects/web-logging/src/lib/logging-proxy.ts","../../../projects/web-logging/src/public-api.ts","../../../projects/web-logging/src/quanticdigit-web-logging.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\n\n/**\n * Livello di un evento di log, nella forma a una lettera che usa il server.\n *\n * @remarks\n * Sono i codici della tabella `Log.LogLevelType`: Fatal, Error, Warning, Info, Debug, Trace. Il\n * client li usa identici a come li scrive il database, cosi' il payload non ha bisogno di essere\n * tradotto da nessuna parte.\n */\nexport type AppLogLevelCode = 'F' | 'E' | 'W' | 'I' | 'D' | 'T';\n\n/**\n * Ordine di gravita': <b>piu' basso e' piu' grave</b>.\n *\n * @remarks\n * Un livello si scrive quando il suo rango e' minore o uguale a quello configurato: configurare `I`\n * fa passare `F`, `E`, `W` e `I` e non `D` ne' `T`. E' la stessa tabella che il motore usa lato\n * server, e le due devono restare uguali o la stessa configurazione produrrebbe due filtri diversi.\n */\nexport const APP_LOG_LEVEL_RANK: Readonly<Record<AppLogLevelCode, number>> = {\n  F: 1,\n  E: 2,\n  W: 3,\n  I: 4,\n  D: 5,\n  T: 6,\n};\n\n/** Un evento pronto per essere scritto. */\nexport interface IApplicationLogEntry {\n  /** Gravita'. */\n  level: AppLogLevelCode;\n  /** Percorso completo, es. `app-reports.eventHandler.onClickApplyFilters`. */\n  path: string;\n  /** Cosa e' successo: `enter`, `exit`, `init`, il messaggio dell'errore. */\n  message: string;\n  /** Dati accessori gia' resi sicuri da `safeValue`. */\n  params?: Record<string, unknown>;\n  /** Stack, quando c'e'. */\n  trace?: string;\n  /** Momento in cui l'evento e' nato, non quello in cui viene spedito. */\n  createdAt: Date;\n}\n\n/**\n * Dove finiscono gli eventi.\n *\n * @remarks\n * <b>E' la sola cosa che il prodotto deve fornire.</b> Questo pacchetto decide <i>se</i> e <i>cosa</i>\n * loggare; come recapitarlo — accodare, raggruppare, chiamare la propria WebApi — lo sa solo chi ha\n * un backend, e cambia da prodotto a prodotto.\n *\n * `write` non deve mai lanciare e non deve mai essere sincrona verso la rete: chi la chiama e' nel\n * mezzo di un metodo applicativo e non ha alcuna intenzione di aspettare.\n */\nexport interface IApplicationLogWriter {\n  write(entry: IApplicationLogEntry): void;\n}\n\n/**\n * Il gancio con cui si accende il log.\n *\n * @remarks\n * <b>Opzionale per costruzione.</b> Gli oggetti base lo cercano con `inject(..., { optional: true })`:\n * dichiarato, si logga; non dichiarato, ogni chiamata di log e' un confronto con `null` e nient'altro.\n * Togliere una riga di provider spegne il log dell'intera applicazione senza toccare una classe.\n */\nexport const APPLICATION_LOG_WRITER = new InjectionToken<IApplicationLogWriter>('QuanticDigit.ApplicationLogWriter');\n\n/**\n * Una riga di configurazione, nella forma in cui il client la tiene.\n *\n * @remarks\n * Rispecchia `Log.ApplicationLogConfig`: un pezzo di percorso, come confrontarlo, fino a che livello\n * scrivere. `path` vuoto con `startsWith` vero e' la riga buona per tutto.\n */\nexport interface IApplicationLogConfigItem {\n  path: string;\n  startsWith: boolean;\n  endsWith: boolean;\n  level: AppLogLevelCode;\n  disabled: boolean;\n}\n\n/**\n * Chiave di `sessionStorage` sotto cui vive la configurazione.\n *\n * @remarks\n * `sessionStorage` e non `localStorage`: la configurazione arriva al login ed e' dell'utente e della\n * sessione: il `sessionStorage.clear()` dell'uscita la porta via senza che nessuno se ne occupi.\n */\nexport const APPLICATION_LOG_CONFIG_KEY = 'log.config';\n","import { APPLICATION_LOG_CONFIG_KEY, APP_LOG_LEVEL_RANK, AppLogLevelCode, IApplicationLogConfigItem } from './contracts';\n\n/**\n * La configurazione del log, letta da `sessionStorage`.\n *\n * @remarks\n * <b>Statica e senza iniezione.</b> La interrogano oggetti che non sono servizi — un proxy su un\n * gestore di eventi, un logger costruito a mano dentro il costruttore di un component — e che quindi\n * non hanno un contesto da cui farsi dare nulla.\n *\n * <b>La regola e' quella del server.</b> Le stesse quattro combinazioni di `startsWith`/`endsWith` e\n * la stessa scelta del livello piu' permissivo fra le righe che corrispondono: una configurazione\n * copiata dal database si comporta qui come si comporterebbe la'. <b>Nessuna riga che corrisponde\n * significa non loggare</b>, non \"loggare tutto\": e' cio' che rende innocuo distribuire il codice di\n * log prima di aver deciso cosa osservare.\n */\nexport class ApplicationLogConfig {\n  /** Ultimo JSON letto, per non deserializzarlo a ogni evento. */\n  private static lastRaw: string | null = null;\n  private static lastParsed: IApplicationLogConfigItem[] = [];\n\n  /** Scrive la configurazione appena ricevuta dal server. */\n  static store(items: IApplicationLogConfigItem[]): void {\n    try {\n      sessionStorage.setItem(APPLICATION_LOG_CONFIG_KEY, JSON.stringify(items ?? []));\n    } catch {\n      // Uno storage pieno o negato non e' un problema dell'applicazione: si resta senza log.\n    }\n    ApplicationLogConfig.lastRaw = null;\n  }\n\n  /** Dimentica la configurazione: da qui in poi non si logga piu' nulla. */\n  static clear(): void {\n    try {\n      sessionStorage.removeItem(APPLICATION_LOG_CONFIG_KEY);\n    } catch {\n      // Come sopra.\n    }\n    ApplicationLogConfig.lastRaw = null;\n    ApplicationLogConfig.lastParsed = [];\n  }\n\n  /** Le righe attive, cosi' come sono. */\n  static items(): readonly IApplicationLogConfigItem[] {\n    let raw: string | null = null;\n    try {\n      raw = sessionStorage.getItem(APPLICATION_LOG_CONFIG_KEY);\n    } catch {\n      return [];\n    }\n\n    if (raw == null || raw === '') {\n      ApplicationLogConfig.lastRaw = null;\n      ApplicationLogConfig.lastParsed = [];\n      return [];\n    }\n\n    if (raw === ApplicationLogConfig.lastRaw) {\n      return ApplicationLogConfig.lastParsed;\n    }\n\n    let parsed: IApplicationLogConfigItem[] = [];\n    try {\n      const read: unknown = JSON.parse(raw);\n      parsed = Array.isArray(read) ? (read as IApplicationLogConfigItem[]) : [];\n    } catch {\n      parsed = [];\n    }\n\n    ApplicationLogConfig.lastRaw = raw;\n    ApplicationLogConfig.lastParsed = parsed;\n    return parsed;\n  }\n\n  /**\n   * Fino a che livello si scrive per questo percorso, oppure `null` se non si scrive affatto.\n   *\n   * @remarks\n   * Fra piu' righe che corrispondono vince la <b>piu' verbosa</b>: chi aggiunge una riga a `D` per\n   * un solo percorso non deve prima togliere quella generale a `I`.\n   */\n  static maxLevelFor(path: string): AppLogLevelCode | null {\n    const rows: readonly IApplicationLogConfigItem[] = ApplicationLogConfig.items();\n    let best: AppLogLevelCode | null = null;\n    let bestRank = 0;\n\n    for (const row of rows) {\n      if (row == null || row.disabled) {\n        continue;\n      }\n      if (!ApplicationLogConfig.matches(path, row)) {\n        continue;\n      }\n      const rank: number = APP_LOG_LEVEL_RANK[row.level] ?? 0;\n      if (rank > bestRank) {\n        bestRank = rank;\n        best = row.level;\n      }\n    }\n\n    return best;\n  }\n\n  /** Vero se il livello richiesto rientra in quello configurato per il percorso. */\n  static isLoggable(level: AppLogLevelCode, path: string): boolean {\n    const max: AppLogLevelCode | null = ApplicationLogConfig.maxLevelFor(path);\n    if (max == null) {\n      return false;\n    }\n    return APP_LOG_LEVEL_RANK[level] <= APP_LOG_LEVEL_RANK[max];\n  }\n\n  /**\n   * Le quattro combinazioni di confronto.\n   *\n   * @remarks\n   * Entrambi i flag significa uguaglianza esatta, nessuno dei due significa \"contiene\": e' la\n   * lettura che ne fa `LoggerBase.FilterConfig` lato .NET, e non va reinventata.\n   */\n  private static matches(path: string, row: IApplicationLogConfigItem): boolean {\n    const expected: string = row.path ?? '';\n    if (row.startsWith && row.endsWith) {\n      return path === expected;\n    }\n    if (row.startsWith) {\n      return path.startsWith(expected);\n    }\n    if (row.endsWith) {\n      return path.endsWith(expected);\n    }\n    return path.includes(expected);\n  }\n}\n","import { ApplicationLogConfig } from './application-log-config';\nimport { AppLogLevelCode, IApplicationLogWriter } from './contracts';\n\n/**\n * Il punto da cui si logga.\n *\n * @remarks\n * <b>Non e' un servizio.</b> Lo costruiscono gli oggetti base dentro il proprio costruttore, con il\n * writer che hanno trovato — o non trovato — nel contesto di iniezione. Un logger senza writer non e'\n * un errore: e' il caso normale di chi non ha acceso il log, e ogni sua chiamata costa un confronto.\n *\n * <b>Non lancia mai.</b> Un log che rompe la schermata che stava osservando e' peggio di nessun log:\n * tutto cio' che sta dentro `log` e' avvolto, writer compreso.\n */\nexport class ApplicationLogger {\n  constructor(\n    private readonly writer: IApplicationLogWriter | null,\n    readonly path: string\n  ) {}\n\n  /**\n   * Vero se questo livello verrebbe scritto.\n   *\n   * @remarks\n   * Va chiamata <b>prima</b> di costruire i dati accessori: e' l'unico modo perche' serializzare gli\n   * argomenti di una chiamata costi zero quando il livello `T` non e' acceso.\n   */\n  isLoggable(level: AppLogLevelCode, subPath?: string): boolean {\n    if (this.writer == null) {\n      return false;\n    }\n    try {\n      return ApplicationLogConfig.isLoggable(level, this.fullPath(subPath));\n    } catch {\n      return false;\n    }\n  }\n\n  /** Scrive un evento, se la configurazione lo prevede. */\n  log(level: AppLogLevelCode, subPath: string | null, message: string, params?: Record<string, unknown>, trace?: string): void {\n    const writer: IApplicationLogWriter | null = this.writer;\n    if (writer == null) {\n      return;\n    }\n    try {\n      const path: string = this.fullPath(subPath ?? undefined);\n      if (!ApplicationLogConfig.isLoggable(level, path)) {\n        return;\n      }\n      writer.write({\n        level,\n        path,\n        message: message ?? '',\n        params,\n        trace,\n        createdAt: new Date(),\n      });\n    } catch {\n      // Un log che fallisce non ha niente da dire a nessuno.\n    }\n  }\n\n  /** Un logger sullo stesso writer, un segmento piu' in basso. */\n  child(segment: string): ApplicationLogger {\n    return new ApplicationLogger(this.writer, this.fullPath(segment));\n  }\n\n  private fullPath(subPath?: string): string {\n    return subPath == null || subPath === '' ? this.path : `${this.path}.${subPath}`;\n  }\n}\n","import { ErrorHandler, Injectable, inject } from '@angular/core';\nimport { ApplicationLogger } from './application-logger';\nimport { APPLICATION_LOG_WRITER } from './contracts';\n\n/**\n * Il gestore di ultima istanza di Angular, con una riga di log in piu'.\n *\n * @remarks\n * <b>Copre cio' che nessun altro vede.</b> Il raccoglitore di errori conosce quelli che arrivano dal\n * livello di servizio; il proxy conosce quelli che nascono dentro un gestore. Un errore in un\n * `subscribe`, in un `setTimeout` o in un binding del template non passa da nessuno dei due e finisce\n * qui: e' l'unico punto in cui si scopre che una schermata si e' rotta senza dirlo.\n *\n * Livello `F` e percorso `errors.unhandled`: cio' che arriva qui non e' stato gestito da nessuno, per\n * definizione.\n *\n * Si registra come si registra qualsiasi `ErrorHandler`, e il comportamento normale di Angular resta\n * perche' `super.handleError` viene comunque chiamato.\n */\n@Injectable()\nexport class LoggingErrorHandler extends ErrorHandler {\n  private readonly logger = new ApplicationLogger(inject(APPLICATION_LOG_WRITER, { optional: true }), 'errors');\n\n  override handleError(error: unknown): void {\n    try {\n      const asError = error as Error | null;\n      this.logger.log('F', 'unhandled', asError?.message ?? String(error), undefined, asError?.stack);\n    } catch {\n      // Il gestore di ultima istanza non puo' essere quello che lancia.\n    }\n    super.handleError(error);\n  }\n}\n","/** Profondita' oltre la quale un oggetto diventa una sigla. */\nconst DEFAULT_DEPTH = 2;\n/** Caratteri stimati oltre i quali si smette di descrivere. */\nconst DEFAULT_BUDGET = 2048;\n/** Lunghezza massima di una stringa descritta per intero. */\nconst MAX_TEXT_LENGTH = 512;\n\n/**\n * Riduce un valore qualsiasi a qualcosa che si puo' serializzare e mandare via.\n *\n * @remarks\n * <b>Serve perche' gli argomenti veri non sono serializzabili.</b> Un gestore di eventi riceve\n * l'evento di DevExtreme, che porta con se' il componente, l'elemento del DOM e da li' l'intera\n * pagina: `JSON.stringify` ci gira in tondo o produce megabyte. Qui quell'oggetto diventa\n * `{ type: 'Object' }` e la chiamata resta leggibile senza essere pericolosa.\n *\n * Tre limiti, tutti volontari: profondita', numero di caratteri, e riconoscimento delle cose che non\n * vanno descritte (nodi, eventi, funzioni). Chi legge un log vuole sapere <i>che</i> e' stato passato\n * un evento, non cosa contenga.\n */\nexport function safeValue(value: unknown, depth: number = DEFAULT_DEPTH, budget: number = DEFAULT_BUDGET): unknown {\n  return reduce(value, depth, { left: budget }, new WeakSet<object>());\n}\n\ninterface Budget {\n  left: number;\n}\n\nfunction reduce(value: unknown, depth: number, budget: Budget, seen: WeakSet<object>): unknown {\n  if (budget.left <= 0) {\n    return '[truncated]';\n  }\n\n  if (value === null || value === undefined) {\n    return value ?? null;\n  }\n\n  const kind: string = typeof value;\n\n  if (kind === 'string') {\n    const text: string = value as string;\n    budget.left -= text.length;\n    return text.length > MAX_TEXT_LENGTH ? `${text.substring(0, MAX_TEXT_LENGTH)}…` : text;\n  }\n\n  if (kind === 'number' || kind === 'boolean') {\n    budget.left -= 8;\n    return value;\n  }\n\n  if (kind === 'bigint' || kind === 'symbol') {\n    budget.left -= 8;\n    return String(value);\n  }\n\n  if (kind === 'function') {\n    budget.left -= 10;\n    return '[function]';\n  }\n\n  if (value instanceof Date) {\n    budget.left -= 24;\n    return value.toISOString();\n  }\n\n  if (value instanceof Error) {\n    budget.left -= 32;\n    return { name: value.name, message: value.message };\n  }\n\n  const target: object = value as object;\n\n  if (seen.has(target)) {\n    return '[circular]';\n  }\n\n  if (isOpaque(target)) {\n    budget.left -= 16;\n    return { type: typeNameOf(target) };\n  }\n\n  if (depth <= 0) {\n    budget.left -= 16;\n    return { type: typeNameOf(target) };\n  }\n\n  seen.add(target);\n  try {\n    if (Array.isArray(value)) {\n      const list: unknown[] = [];\n      for (const item of value) {\n        if (budget.left <= 0) {\n          list.push('[truncated]');\n          break;\n        }\n        list.push(reduce(item, depth - 1, budget, seen));\n      }\n      return list;\n    }\n\n    const result: Record<string, unknown> = {};\n    for (const key of Object.keys(target)) {\n      if (budget.left <= 0) {\n        result['…'] = '[truncated]';\n        break;\n      }\n      budget.left -= key.length;\n      result[key] = reduce((target as Record<string, unknown>)[key], depth - 1, budget, seen);\n    }\n    return result;\n  } catch {\n    return '[unreadable]';\n  } finally {\n    seen.delete(target);\n  }\n}\n\n/**\n * Cose che non si descrivono mai: nodi del DOM, eventi, e gli argomenti di DevExtreme.\n *\n * @remarks\n * Gli eventi di DevExtreme non ereditano da `Event`: sono oggetti semplici con `component` ed\n * `element` dentro, e da li' si arriva a tutto. Si riconoscono dalla forma perche' non c'e' un tipo\n * da cui dipendere, e questo pacchetto non dipende da DevExtreme.\n */\nfunction isOpaque(value: object): boolean {\n  if (typeof Node !== 'undefined' && value instanceof Node) {\n    return true;\n  }\n  if (typeof Event !== 'undefined' && value instanceof Event) {\n    return true;\n  }\n  const candidate: Record<string, unknown> = value as Record<string, unknown>;\n  return candidate['component'] !== undefined && candidate['element'] !== undefined;\n}\n\nfunction typeNameOf(value: object): string {\n  try {\n    return value.constructor?.name ?? 'Object';\n  } catch {\n    return 'Object';\n  }\n}\n","import { ApplicationLogger } from './application-logger';\nimport { safeValue } from './safe-value';\n\n/**\n * Metodi che non si loggano mai.\n *\n * @remarks\n * Sono l'impalcatura: la costruzione degli oggetti base e i ganci del ciclo di vita di Angular, che\n * il component gia' registra per conto proprio. Loggarli raddoppierebbe le righe senza aggiungere\n * nulla. Tutto cio' che inizia per `ng` e' escluso per la stessa ragione.\n */\nexport const DEFAULT_EXCLUDED: ReadonlySet<string> = new Set<string>(['constructor', 'init', 'onInit', 'getActionHandler']);\n\n/**\n * Avvolge un oggetto perche' ogni sua chiamata di metodo lasci traccia.\n *\n * @remarks\n * <b>E' cio' che rende il log gratuito per chi scrive le schermate.</b> Il gestore di eventi e quello\n * delle azioni non sanno di essere osservati e non hanno una riga in piu': l'oggetto base li consegna\n * avvolti, e da quel momento ogni metodo chiamato dal template o dal gestore registra ingresso,\n * uscita, durata ed eventuale eccezione.\n *\n * <b>Il metodo viene invocato sull'oggetto vero</b>, non sul proxy: i campi privati `#` continuano a\n * funzionare, e le chiamate che l'oggetto fa a se' stesso non riattraversano il proxy. E' voluto —\n * si vuole la chiamata che arriva da fuori, non la ricorsione interna.\n *\n * Senza writer o senza configurazione il costo e' la trap `get` piu' un confronto: nessun oggetto\n * costruito, nessun argomento serializzato.\n */\nexport function wrapWithLogging<T extends object>(target: T, logger: ApplicationLogger, excluded: ReadonlySet<string> = DEFAULT_EXCLUDED): T {\n  if (target == null) {\n    return target;\n  }\n\n  const wrappers = new Map<string, (...args: unknown[]) => unknown>();\n\n  return new Proxy(target, {\n    get(instance: T, prop: string | symbol): unknown {\n      const value: unknown = Reflect.get(instance, prop, instance);\n\n      if (typeof prop === 'symbol' || typeof value !== 'function' || excluded.has(prop) || prop.startsWith('ng')) {\n        return value;\n      }\n\n      const cached = wrappers.get(prop);\n      if (cached != null) {\n        return cached;\n      }\n\n      const original = value as (...args: unknown[]) => unknown;\n      const name: string = prop;\n\n      const wrapper = function (...args: unknown[]): unknown {\n        if (!logger.isLoggable('D', name)) {\n          return original.apply(instance, args);\n        }\n\n        const detailed: boolean = logger.isLoggable('T', name);\n        logger.log('D', name, 'enter', detailed ? { args: args.map((A: unknown) => safeValue(A)) } : undefined);\n        const startedAt: number = now();\n\n        try {\n          const result: unknown = original.apply(instance, args);\n\n          if (result instanceof Promise) {\n            result.then(\n              (resolved: unknown) => logger.log('D', name, 'exit', detailed ? { durationMs: now() - startedAt, result: safeValue(resolved) } : { durationMs: now() - startedAt }),\n              (rejection: unknown) => logger.log('E', name, 'error', { durationMs: now() - startedAt }, stackOf(rejection))\n            );\n            return result;\n          }\n\n          logger.log('D', name, 'exit', detailed ? { durationMs: now() - startedAt, result: safeValue(result) } : { durationMs: now() - startedAt });\n          return result;\n        } catch (error: unknown) {\n          logger.log('E', name, 'error', { durationMs: now() - startedAt }, stackOf(error));\n          // Il log osserva, non decide: l'eccezione prosegue verso chi la sa gestire.\n          throw error;\n        }\n      };\n\n      wrappers.set(prop, wrapper);\n      return wrapper;\n    },\n  });\n}\n\nfunction now(): number {\n  return typeof performance !== 'undefined' && performance.now != null ? performance.now() : Date.now();\n}\n\nfunction stackOf(error: unknown): string {\n  const asError = error as Error | null;\n  return asError?.stack ?? String(error);\n}\n","/**\n * Superficie pubblica di `@quanticdigit/web-logging`.\n *\n * Il log applicativo del client: ingresso e uscita dalle schermate, ogni chiamata ai gestori di\n * eventi e di azioni, e gli errori — tutto filtrato da una configurazione che decide il server e\n * recapitato da un writer che fornisce il prodotto.\n *\n * <b>Due sole cose vanno capite per usarlo.</b>\n *\n * 1. **il writer** — si dichiara `APPLICATION_LOG_WRITER` e il log si accende; non dichiararlo lo\n *    spegne ovunque, perche' gli oggetti base lo cercano come opzionale e senza di lui non fanno\n *    nulla. Questo pacchetto non parla con nessun backend: non sa quale sia.\n * 2. **la configurazione** — sta in `sessionStorage` sotto `log.config` e arriva dal server al\n *    momento del login. Senza righe che corrispondono <b>non si logga</b>: il codice di log puo'\n *    essere distribuito molto prima di aver deciso cosa osservare, e non costa nulla finche' nessuno\n *    lo accende.\n *\n * Chi usa `@quanticdigit/web-component` e `@quanticdigit/web-errors` non deve fare altro: gli oggetti\n * base sono gia' agganciati. Il resto di questa superficie serve a chi vuole loggare a mano\n * (`ApplicationLogger`) o avvolgere oggetti propri (`wrapWithLogging`).\n */\n\nexport * from './lib/application-log-config';\nexport * from './lib/application-logger';\nexport * from './lib/contracts';\nexport * from './lib/logging-error-handler';\nexport * from './lib/logging-proxy';\nexport * from './lib/safe-value';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@quanticdigit/web-logging",
+  "version": "1.0.3",
+  "description": "Application log for the client: component lifecycle, handler calls and errors, filtered by a server-side configuration and sent through a writer you provide.",
+  "author": "Quantic Digit S.R.L.",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "homepage": "https://www.quanticdigit.it/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/quanticdigit/library.git"
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "@angular/core": "^21.2.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2022/quanticdigit-web-logging.mjs",
+  "typings": "types/quanticdigit-web-logging.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/quanticdigit-web-logging.d.ts",
+      "default": "./fesm2022/quanticdigit-web-logging.mjs"
+    }
+  },
+  "type": "module"
+}

package/types/quanticdigit-web-logging.d.ts

@@ -0,0 +1,222 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ErrorHandler } from '@angular/core';
+
+/**
+ * Livello di un evento di log, nella forma a una lettera che usa il server.
+ *
+ * @remarks
+ * Sono i codici della tabella `Log.LogLevelType`: Fatal, Error, Warning, Info, Debug, Trace. Il
+ * client li usa identici a come li scrive il database, cosi' il payload non ha bisogno di essere
+ * tradotto da nessuna parte.
+ */
+type AppLogLevelCode = 'F' | 'E' | 'W' | 'I' | 'D' | 'T';
+/**
+ * Ordine di gravita': <b>piu' basso e' piu' grave</b>.
+ *
+ * @remarks
+ * Un livello si scrive quando il suo rango e' minore o uguale a quello configurato: configurare `I`
+ * fa passare `F`, `E`, `W` e `I` e non `D` ne' `T`. E' la stessa tabella che il motore usa lato
+ * server, e le due devono restare uguali o la stessa configurazione produrrebbe due filtri diversi.
+ */
+declare const APP_LOG_LEVEL_RANK: Readonly<Record<AppLogLevelCode, number>>;
+/** Un evento pronto per essere scritto. */
+interface IApplicationLogEntry {
+    /** Gravita'. */
+    level: AppLogLevelCode;
+    /** Percorso completo, es. `app-reports.eventHandler.onClickApplyFilters`. */
+    path: string;
+    /** Cosa e' successo: `enter`, `exit`, `init`, il messaggio dell'errore. */
+    message: string;
+    /** Dati accessori gia' resi sicuri da `safeValue`. */
+    params?: Record<string, unknown>;
+    /** Stack, quando c'e'. */
+    trace?: string;
+    /** Momento in cui l'evento e' nato, non quello in cui viene spedito. */
+    createdAt: Date;
+}
+/**
+ * Dove finiscono gli eventi.
+ *
+ * @remarks
+ * <b>E' la sola cosa che il prodotto deve fornire.</b> Questo pacchetto decide <i>se</i> e <i>cosa</i>
+ * loggare; come recapitarlo — accodare, raggruppare, chiamare la propria WebApi — lo sa solo chi ha
+ * un backend, e cambia da prodotto a prodotto.
+ *
+ * `write` non deve mai lanciare e non deve mai essere sincrona verso la rete: chi la chiama e' nel
+ * mezzo di un metodo applicativo e non ha alcuna intenzione di aspettare.
+ */
+interface IApplicationLogWriter {
+    write(entry: IApplicationLogEntry): void;
+}
+/**
+ * Il gancio con cui si accende il log.
+ *
+ * @remarks
+ * <b>Opzionale per costruzione.</b> Gli oggetti base lo cercano con `inject(..., { optional: true })`:
+ * dichiarato, si logga; non dichiarato, ogni chiamata di log e' un confronto con `null` e nient'altro.
+ * Togliere una riga di provider spegne il log dell'intera applicazione senza toccare una classe.
+ */
+declare const APPLICATION_LOG_WRITER: InjectionToken<IApplicationLogWriter>;
+/**
+ * Una riga di configurazione, nella forma in cui il client la tiene.
+ *
+ * @remarks
+ * Rispecchia `Log.ApplicationLogConfig`: un pezzo di percorso, come confrontarlo, fino a che livello
+ * scrivere. `path` vuoto con `startsWith` vero e' la riga buona per tutto.
+ */
+interface IApplicationLogConfigItem {
+    path: string;
+    startsWith: boolean;
+    endsWith: boolean;
+    level: AppLogLevelCode;
+    disabled: boolean;
+}
+/**
+ * Chiave di `sessionStorage` sotto cui vive la configurazione.
+ *
+ * @remarks
+ * `sessionStorage` e non `localStorage`: la configurazione arriva al login ed e' dell'utente e della
+ * sessione: il `sessionStorage.clear()` dell'uscita la porta via senza che nessuno se ne occupi.
+ */
+declare const APPLICATION_LOG_CONFIG_KEY = "log.config";
+
+/**
+ * La configurazione del log, letta da `sessionStorage`.
+ *
+ * @remarks
+ * <b>Statica e senza iniezione.</b> La interrogano oggetti che non sono servizi — un proxy su un
+ * gestore di eventi, un logger costruito a mano dentro il costruttore di un component — e che quindi
+ * non hanno un contesto da cui farsi dare nulla.
+ *
+ * <b>La regola e' quella del server.</b> Le stesse quattro combinazioni di `startsWith`/`endsWith` e
+ * la stessa scelta del livello piu' permissivo fra le righe che corrispondono: una configurazione
+ * copiata dal database si comporta qui come si comporterebbe la'. <b>Nessuna riga che corrisponde
+ * significa non loggare</b>, non "loggare tutto": e' cio' che rende innocuo distribuire il codice di
+ * log prima di aver deciso cosa osservare.
+ */
+declare class ApplicationLogConfig {
+    /** Ultimo JSON letto, per non deserializzarlo a ogni evento. */
+    private static lastRaw;
+    private static lastParsed;
+    /** Scrive la configurazione appena ricevuta dal server. */
+    static store(items: IApplicationLogConfigItem[]): void;
+    /** Dimentica la configurazione: da qui in poi non si logga piu' nulla. */
+    static clear(): void;
+    /** Le righe attive, cosi' come sono. */
+    static items(): readonly IApplicationLogConfigItem[];
+    /**
+     * Fino a che livello si scrive per questo percorso, oppure `null` se non si scrive affatto.
+     *
+     * @remarks
+     * Fra piu' righe che corrispondono vince la <b>piu' verbosa</b>: chi aggiunge una riga a `D` per
+     * un solo percorso non deve prima togliere quella generale a `I`.
+     */
+    static maxLevelFor(path: string): AppLogLevelCode | null;
+    /** Vero se il livello richiesto rientra in quello configurato per il percorso. */
+    static isLoggable(level: AppLogLevelCode, path: string): boolean;
+    /**
+     * Le quattro combinazioni di confronto.
+     *
+     * @remarks
+     * Entrambi i flag significa uguaglianza esatta, nessuno dei due significa "contiene": e' la
+     * lettura che ne fa `LoggerBase.FilterConfig` lato .NET, e non va reinventata.
+     */
+    private static matches;
+}
+
+/**
+ * Il punto da cui si logga.
+ *
+ * @remarks
+ * <b>Non e' un servizio.</b> Lo costruiscono gli oggetti base dentro il proprio costruttore, con il
+ * writer che hanno trovato — o non trovato — nel contesto di iniezione. Un logger senza writer non e'
+ * un errore: e' il caso normale di chi non ha acceso il log, e ogni sua chiamata costa un confronto.
+ *
+ * <b>Non lancia mai.</b> Un log che rompe la schermata che stava osservando e' peggio di nessun log:
+ * tutto cio' che sta dentro `log` e' avvolto, writer compreso.
+ */
+declare class ApplicationLogger {
+    private readonly writer;
+    readonly path: string;
+    constructor(writer: IApplicationLogWriter | null, path: string);
+    /**
+     * Vero se questo livello verrebbe scritto.
+     *
+     * @remarks
+     * Va chiamata <b>prima</b> di costruire i dati accessori: e' l'unico modo perche' serializzare gli
+     * argomenti di una chiamata costi zero quando il livello `T` non e' acceso.
+     */
+    isLoggable(level: AppLogLevelCode, subPath?: string): boolean;
+    /** Scrive un evento, se la configurazione lo prevede. */
+    log(level: AppLogLevelCode, subPath: string | null, message: string, params?: Record<string, unknown>, trace?: string): void;
+    /** Un logger sullo stesso writer, un segmento piu' in basso. */
+    child(segment: string): ApplicationLogger;
+    private fullPath;
+}
+
+/**
+ * Il gestore di ultima istanza di Angular, con una riga di log in piu'.
+ *
+ * @remarks
+ * <b>Copre cio' che nessun altro vede.</b> Il raccoglitore di errori conosce quelli che arrivano dal
+ * livello di servizio; il proxy conosce quelli che nascono dentro un gestore. Un errore in un
+ * `subscribe`, in un `setTimeout` o in un binding del template non passa da nessuno dei due e finisce
+ * qui: e' l'unico punto in cui si scopre che una schermata si e' rotta senza dirlo.
+ *
+ * Livello `F` e percorso `errors.unhandled`: cio' che arriva qui non e' stato gestito da nessuno, per
+ * definizione.
+ *
+ * Si registra come si registra qualsiasi `ErrorHandler`, e il comportamento normale di Angular resta
+ * perche' `super.handleError` viene comunque chiamato.
+ */
+declare class LoggingErrorHandler extends ErrorHandler {
+    private readonly logger;
+    handleError(error: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoggingErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoggingErrorHandler>;
+}
+
+/**
+ * Metodi che non si loggano mai.
+ *
+ * @remarks
+ * Sono l'impalcatura: la costruzione degli oggetti base e i ganci del ciclo di vita di Angular, che
+ * il component gia' registra per conto proprio. Loggarli raddoppierebbe le righe senza aggiungere
+ * nulla. Tutto cio' che inizia per `ng` e' escluso per la stessa ragione.
+ */
+declare const DEFAULT_EXCLUDED: ReadonlySet<string>;
+/**
+ * Avvolge un oggetto perche' ogni sua chiamata di metodo lasci traccia.
+ *
+ * @remarks
+ * <b>E' cio' che rende il log gratuito per chi scrive le schermate.</b> Il gestore di eventi e quello
+ * delle azioni non sanno di essere osservati e non hanno una riga in piu': l'oggetto base li consegna
+ * avvolti, e da quel momento ogni metodo chiamato dal template o dal gestore registra ingresso,
+ * uscita, durata ed eventuale eccezione.
+ *
+ * <b>Il metodo viene invocato sull'oggetto vero</b>, non sul proxy: i campi privati `#` continuano a
+ * funzionare, e le chiamate che l'oggetto fa a se' stesso non riattraversano il proxy. E' voluto —
+ * si vuole la chiamata che arriva da fuori, non la ricorsione interna.
+ *
+ * Senza writer o senza configurazione il costo e' la trap `get` piu' un confronto: nessun oggetto
+ * costruito, nessun argomento serializzato.
+ */
+declare function wrapWithLogging<T extends object>(target: T, logger: ApplicationLogger, excluded?: ReadonlySet<string>): T;
+
+/**
+ * Riduce un valore qualsiasi a qualcosa che si puo' serializzare e mandare via.
+ *
+ * @remarks
+ * <b>Serve perche' gli argomenti veri non sono serializzabili.</b> Un gestore di eventi riceve
+ * l'evento di DevExtreme, che porta con se' il componente, l'elemento del DOM e da li' l'intera
+ * pagina: `JSON.stringify` ci gira in tondo o produce megabyte. Qui quell'oggetto diventa
+ * `{ type: 'Object' }` e la chiamata resta leggibile senza essere pericolosa.
+ *
+ * Tre limiti, tutti volontari: profondita', numero di caratteri, e riconoscimento delle cose che non
+ * vanno descritte (nodi, eventi, funzioni). Chi legge un log vuole sapere <i>che</i> e' stato passato
+ * un evento, non cosa contenga.
+ */
+declare function safeValue(value: unknown, depth?: number, budget?: number): unknown;
+
+export { APPLICATION_LOG_CONFIG_KEY, APPLICATION_LOG_WRITER, APP_LOG_LEVEL_RANK, ApplicationLogConfig, ApplicationLogger, DEFAULT_EXCLUDED, LoggingErrorHandler, safeValue, wrapWithLogging };
+export type { AppLogLevelCode, IApplicationLogConfigItem, IApplicationLogEntry, IApplicationLogWriter };