@henrique-olivier/network-listener 0.1.0

package/README.md

@@ -0,0 +1,122 @@
+# Lib Escutadora de Rede
+
+POC de uma biblioteca leve e agnostica de framework para observar requisicoes HTTP no front-end e produzir diagnosticos provaveis sobre lentidao, erro ou instabilidade.
+
+## Objetivos
+
+- observar requisicoes feitas via `fetch`;
+- observar requisicoes feitas via Axios;
+- manter uma janela das ultimas requisicoes em memoria;
+- normalizar rotas para reduzir exposicao de dados sensiveis;
+- calcular metricas simples;
+- classificar o estado atual da comunicacao;
+- expor uma API simples para qualquer front-end, inclusive projetos legados.
+
+## Compatibilidade
+
+O build da POC foi configurado para:
+
+- CommonJS;
+- JavaScript ES5;
+- declaracoes TypeScript;
+- sem dependencia de React;
+- sem dependencia obrigatoria de Axios;
+- sem polyfills globais;
+- sem leitura de body de request ou response.
+
+## Uso
+
+```ts
+import { createNetworkListener } from '@henrique-olivier/network-listener';
+
+const listener = createNetworkListener({
+  slowRequestThresholdMs: 1500,
+  maxSamples: 20,
+  minimumSamplesToDiagnose: 5,
+});
+
+listener.installFetch();
+listener.installAxios(axiosInstance);
+
+const unsubscribe = listener.subscribe(function (diagnosis) {
+  console.log(diagnosis);
+});
+
+listener.start();
+
+// Depois, quando nao precisar mais observar:
+listener.stop();
+unsubscribe();
+```
+
+## Diagnostico
+
+O snapshot atual pode ser obtido a qualquer momento:
+
+```ts
+const diagnosis = listener.getSnapshot();
+```
+
+Exemplo de retorno:
+
+```ts
+{
+  status: 'degraded',
+  probableCause: 'specific-endpoint',
+  confidenceLevel: 'medium',
+  reasons: ['Only one endpoint concentrates slow requests.'],
+  summary: {
+    requestCount: 20,
+    errorRate: 0,
+    timeoutRate: 0,
+    slowRequestRate: 0.35,
+    medianDurationMs: 700,
+    p95DurationMs: 2300,
+    affectedEndpointRatio: 0.2
+  }
+}
+```
+
+## Privacidade
+
+A lib nao coleta por padrao:
+
+- headers;
+- cookies;
+- payload;
+- corpo de resposta;
+- query strings completas;
+- geolocalizacao;
+- IP.
+
+O principal identificador tecnico e `normalizedRoute`.
+
+Exemplo:
+
+```txt
+/api/users/123/orders?token=abc
+```
+
+vira:
+
+```txt
+/api/users/:id/orders
+```
+
+## Scripts
+
+```bash
+npm test
+npm run build
+```
+
+## Escopo fora da POC
+
+- XHR;
+- health-check automatico;
+- teste de download;
+- PerformanceObserver;
+- Server-Timing;
+- navigator.connection;
+- dashboard;
+- envio de telemetria para backend.

package/dist/adapters/axiosAdapter.d.ts

@@ -0,0 +1,11 @@
+import { AxiosLike, NetworkRequestEvent, RouteNormalizer, Uninstall } from '../core/types';
+export type AxiosAdapterOptions = {
+    axiosInstance: AxiosLike;
+    isStarted: () => boolean;
+    onEvent: (event: NetworkRequestEvent) => void;
+    routeNormalizer: RouteNormalizer;
+    timeoutThresholdMs: number;
+    now: () => number;
+    nextRequestId: () => string;
+};
+export declare function installAxiosAdapter(options: AxiosAdapterOptions): Uninstall;

package/dist/adapters/axiosAdapter.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installAxiosAdapter = void 0;
+var META_KEY = '__networkListenerMeta';
+function buildAxiosUrl(config) {
+    var baseURL = config && config.baseURL ? String(config.baseURL) : '';
+    var url = config && config.url ? String(config.url) : '';
+    if (!baseURL || url.indexOf('http://') === 0 || url.indexOf('https://') === 0 || url.indexOf('//') === 0) {
+        return url;
+    }
+    if (baseURL.charAt(baseURL.length - 1) === '/' && url.charAt(0) === '/') {
+        return baseURL + url.substring(1);
+    }
+    if (baseURL.charAt(baseURL.length - 1) !== '/' && url.charAt(0) !== '/') {
+        return baseURL + '/' + url;
+    }
+    return baseURL + url;
+}
+function getAxiosMethod(config) {
+    return config && config.method ? String(config.method).toUpperCase() : 'GET';
+}
+function classifyAxiosError(error, durationMs, timeoutThresholdMs) {
+    var code = error && error.code ? String(error.code) : '';
+    var message = error && error.message ? String(error.message) : '';
+    var status = error && error.response && typeof error.response.status === 'number' ? error.response.status : undefined;
+    var timedOut = code === 'ECONNABORTED' || durationMs >= timeoutThresholdMs || /timeout/i.test(message);
+    if (timedOut) {
+        return { errorType: 'timeout', timedOut: true, aborted: false };
+    }
+    if (status && status >= 500) {
+        return { errorType: 'http-server', timedOut: false, aborted: false };
+    }
+    if (status && status >= 400) {
+        return { errorType: 'http-client', timedOut: false, aborted: false };
+    }
+    if (code === 'ERR_CANCELED') {
+        return { errorType: 'aborted', timedOut: false, aborted: true };
+    }
+    return { errorType: 'network', timedOut: false, aborted: false };
+}
+function installAxiosAdapter(options) {
+    var axiosInstance = options.axiosInstance;
+    var requestInterceptorId;
+    var responseInterceptorId;
+    requestInterceptorId = axiosInstance.interceptors.request.use(function onRequest(config) {
+        var url = buildAxiosUrl(config || {});
+        var route = options.routeNormalizer(url);
+        config = config || {};
+        config[META_KEY] = {
+            requestId: options.nextRequestId(),
+            startedAt: options.now(),
+            method: getAxiosMethod(config),
+            url: url,
+            route: route,
+        };
+        return config;
+    });
+    responseInterceptorId = axiosInstance.interceptors.response.use(function onResponse(response) {
+        var config = response && response.config ? response.config : {};
+        var meta = config[META_KEY];
+        var finishedAt;
+        var status;
+        var durationMs;
+        var success;
+        if (meta && options.isStarted()) {
+            finishedAt = options.now();
+            status = response && typeof response.status === 'number' ? response.status : undefined;
+            durationMs = finishedAt - meta.startedAt;
+            success = typeof status === 'number' ? status < 400 : true;
+            options.onEvent({
+                requestId: meta.requestId,
+                source: 'axios',
+                method: meta.method,
+                url: meta.url,
+                route: meta.route,
+                normalizedRoute: meta.route,
+                startedAt: meta.startedAt,
+                finishedAt: finishedAt,
+                durationMs: durationMs,
+                status: status,
+                success: success,
+                errorType: success ? undefined : status && status >= 500 ? 'http-server' : 'http-client',
+                timedOut: durationMs >= options.timeoutThresholdMs,
+                aborted: false,
+            });
+        }
+        return response;
+    }, function onError(error) {
+        var config = error && error.config ? error.config : {};
+        var meta = config[META_KEY];
+        var finishedAt;
+        var durationMs;
+        var errorInfo;
+        var status;
+        if (meta && options.isStarted()) {
+            finishedAt = options.now();
+            durationMs = finishedAt - meta.startedAt;
+            errorInfo = classifyAxiosError(error, durationMs, options.timeoutThresholdMs);
+            status = error && error.response && typeof error.response.status === 'number' ? error.response.status : undefined;
+            options.onEvent({
+                requestId: meta.requestId,
+                source: 'axios',
+                method: meta.method,
+                url: meta.url,
+                route: meta.route,
+                normalizedRoute: meta.route,
+                startedAt: meta.startedAt,
+                finishedAt: finishedAt,
+                durationMs: durationMs,
+                status: status,
+                success: false,
+                errorType: errorInfo.errorType,
+                timedOut: errorInfo.timedOut,
+                aborted: errorInfo.aborted,
+            });
+        }
+        throw error;
+    });
+    return function uninstallAxiosAdapter() {
+        axiosInstance.interceptors.request.eject(requestInterceptorId);
+        axiosInstance.interceptors.response.eject(responseInterceptorId);
+    };
+}
+exports.installAxiosAdapter = installAxiosAdapter;

package/dist/adapters/fetchAdapter.d.ts

@@ -0,0 +1,11 @@
+import { FetchTarget, NetworkRequestEvent, RouteNormalizer, Uninstall } from '../core/types';
+export type FetchAdapterOptions = {
+    target?: FetchTarget;
+    isStarted: () => boolean;
+    onEvent: (event: NetworkRequestEvent) => void;
+    routeNormalizer: RouteNormalizer;
+    timeoutThresholdMs: number;
+    now: () => number;
+    nextRequestId: () => string;
+};
+export declare function installFetchAdapter(options: FetchAdapterOptions): Uninstall;

package/dist/adapters/fetchAdapter.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installFetchAdapter = void 0;
+var MARKER = '__networkListenerFetchInstalled';
+var ORIGINAL = '__networkListenerOriginalFetch';
+function getDefaultTarget() {
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    return undefined;
+}
+function getFetchUrl(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (input && typeof input.url === 'string') {
+        return input.url;
+    }
+    return '';
+}
+function getFetchMethod(input, init) {
+    if (init && init.method) {
+        return String(init.method).toUpperCase();
+    }
+    if (input && input.method) {
+        return String(input.method).toUpperCase();
+    }
+    return 'GET';
+}
+function classifyError(error, durationMs, timeoutThresholdMs) {
+    var name = error && error.name ? String(error.name) : '';
+    var message = error && error.message ? String(error.message) : '';
+    var aborted = name === 'AbortError';
+    var timedOut = durationMs >= timeoutThresholdMs || /timeout/i.test(message);
+    return {
+        errorType: timedOut ? 'timeout' : aborted ? 'aborted' : 'network',
+        timedOut: timedOut,
+        aborted: aborted,
+    };
+}
+function installFetchAdapter(options) {
+    var target = options.target || getDefaultTarget();
+    var currentFetch;
+    var originalFetch;
+    if (!target || !target.fetch) {
+        return function noop() { };
+    }
+    currentFetch = target.fetch;
+    if (currentFetch[MARKER]) {
+        return function noop() { };
+    }
+    originalFetch = currentFetch;
+    function wrappedFetch() {
+        var args = arguments;
+        var input = args[0];
+        var init = args[1];
+        var url = getFetchUrl(input);
+        var route = options.routeNormalizer(url);
+        var method = getFetchMethod(input, init);
+        var requestId = options.nextRequestId();
+        var startedAt = options.now();
+        return originalFetch.apply(this, args).then(function onResponse(response) {
+            var finishedAt = options.now();
+            var status = response && typeof response.status === 'number' ? response.status : undefined;
+            var success = typeof status === 'number' ? status < 400 : true;
+            var durationMs = finishedAt - startedAt;
+            if (options.isStarted()) {
+                options.onEvent({
+                    requestId: requestId,
+                    source: 'fetch',
+                    method: method,
+                    url: url,
+                    route: route,
+                    normalizedRoute: route,
+                    startedAt: startedAt,
+                    finishedAt: finishedAt,
+                    durationMs: durationMs,
+                    status: status,
+                    success: success,
+                    errorType: success ? undefined : status && status >= 500 ? 'http-server' : 'http-client',
+                    timedOut: durationMs >= options.timeoutThresholdMs,
+                    aborted: false,
+                });
+            }
+            return response;
+        }, function onError(error) {
+            var finishedAt = options.now();
+            var durationMs = finishedAt - startedAt;
+            var errorInfo = classifyError(error, durationMs, options.timeoutThresholdMs);
+            if (options.isStarted()) {
+                options.onEvent({
+                    requestId: requestId,
+                    source: 'fetch',
+                    method: method,
+                    url: url,
+                    route: route,
+                    normalizedRoute: route,
+                    startedAt: startedAt,
+                    finishedAt: finishedAt,
+                    durationMs: durationMs,
+                    success: false,
+                    errorType: errorInfo.errorType,
+                    timedOut: errorInfo.timedOut,
+                    aborted: errorInfo.aborted,
+                });
+            }
+            throw error;
+        });
+    }
+    wrappedFetch[MARKER] = true;
+    wrappedFetch[ORIGINAL] = originalFetch;
+    target.fetch = wrappedFetch;
+    return function uninstallFetchAdapter() {
+        if (target && target.fetch === wrappedFetch) {
+            target.fetch = originalFetch;
+        }
+    };
+}
+exports.installFetchAdapter = installFetchAdapter;

package/dist/core/createNetworkListener.d.ts

@@ -0,0 +1,2 @@
+import { NetworkListener, NetworkListenerOptions } from './types';
+export declare function createNetworkListener(options?: NetworkListenerOptions): NetworkListener;

package/dist/core/createNetworkListener.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNetworkListener = void 0;
+var axiosAdapter_1 = require("../adapters/axiosAdapter");
+var fetchAdapter_1 = require("../adapters/fetchAdapter");
+var metricsStore_1 = require("./metricsStore");
+var routeNormalizer_1 = require("./routeNormalizer");
+var ruleEngine_1 = require("./ruleEngine");
+var DEFAULT_SLOW_REQUEST_THRESHOLD_MS = 1500;
+var DEFAULT_MAX_SAMPLES = 20;
+var DEFAULT_MINIMUM_SAMPLES_TO_DIAGNOSE = 5;
+var DEFAULT_TIMEOUT_THRESHOLD_MS = 30000;
+function now() {
+    return new Date().getTime();
+}
+function createNetworkListener(options) {
+    var resolvedOptions = options || {};
+    var slowRequestThresholdMs = resolvedOptions.slowRequestThresholdMs || DEFAULT_SLOW_REQUEST_THRESHOLD_MS;
+    var maxSamples = resolvedOptions.maxSamples || DEFAULT_MAX_SAMPLES;
+    var minimumSamplesToDiagnose = resolvedOptions.minimumSamplesToDiagnose || DEFAULT_MINIMUM_SAMPLES_TO_DIAGNOSE;
+    var timeoutThresholdMs = resolvedOptions.timeoutThresholdMs || DEFAULT_TIMEOUT_THRESHOLD_MS;
+    var routeNormalizer = resolvedOptions.routeNormalizer || routeNormalizer_1.defaultRouteNormalizer;
+    var store = (0, metricsStore_1.createMetricsStore)({
+        maxSamples: maxSamples,
+        slowRequestThresholdMs: slowRequestThresholdMs,
+    });
+    var subscribers = [];
+    var started = false;
+    var requestSequence = 0;
+    var fetchUninstall;
+    var axiosUninstalls = [];
+    function nextRequestId() {
+        requestSequence += 1;
+        return 'nl_' + now() + '_' + requestSequence;
+    }
+    function getSnapshot() {
+        return (0, ruleEngine_1.diagnoseNetwork)(store.getEvents(), {
+            minimumSamplesToDiagnose: minimumSamplesToDiagnose,
+            slowRequestThresholdMs: slowRequestThresholdMs,
+        });
+    }
+    function notify() {
+        var snapshot = getSnapshot();
+        var copy = subscribers.slice();
+        var i;
+        for (i = 0; i < copy.length; i += 1) {
+            copy[i](snapshot);
+        }
+    }
+    function record(event) {
+        store.add(event);
+        notify();
+    }
+    return {
+        start: function start() {
+            started = true;
+        },
+        stop: function stop() {
+            started = false;
+        },
+        subscribe: function subscribe(subscriber) {
+            subscribers.push(subscriber);
+            return function unsubscribe() {
+                var index = subscribers.indexOf(subscriber);
+                if (index >= 0) {
+                    subscribers.splice(index, 1);
+                }
+            };
+        },
+        getSnapshot: getSnapshot,
+        record: record,
+        installFetch: function installFetch(target) {
+            if (fetchUninstall) {
+                return fetchUninstall;
+            }
+            fetchUninstall = (0, fetchAdapter_1.installFetchAdapter)({
+                target: target,
+                isStarted: function isStarted() {
+                    return started;
+                },
+                onEvent: record,
+                routeNormalizer: routeNormalizer,
+                timeoutThresholdMs: timeoutThresholdMs,
+                now: now,
+                nextRequestId: nextRequestId,
+            });
+            return fetchUninstall;
+        },
+        installAxios: function installAxios(axiosInstance) {
+            var uninstall = (0, axiosAdapter_1.installAxiosAdapter)({
+                axiosInstance: axiosInstance,
+                isStarted: function isStarted() {
+                    return started;
+                },
+                onEvent: record,
+                routeNormalizer: routeNormalizer,
+                timeoutThresholdMs: timeoutThresholdMs,
+                now: now,
+                nextRequestId: nextRequestId,
+            });
+            axiosUninstalls.push(uninstall);
+            return function uninstallAxios() {
+                var index = axiosUninstalls.indexOf(uninstall);
+                if (index >= 0) {
+                    axiosUninstalls.splice(index, 1);
+                }
+                uninstall();
+            };
+        },
+    };
+}
+exports.createNetworkListener = createNetworkListener;

package/dist/core/metricsStore.d.ts

@@ -0,0 +1,13 @@
+import { NetworkRequestEvent, NetworkSummary } from './types';
+export type MetricsStore = {
+    add: (event: NetworkRequestEvent) => NetworkSummary;
+    getEvents: () => NetworkRequestEvent[];
+    getSummary: () => NetworkSummary;
+    clear: () => void;
+};
+export type MetricsStoreOptions = {
+    maxSamples: number;
+    slowRequestThresholdMs: number;
+};
+export declare function calculateSummary(events: NetworkRequestEvent[], slowRequestThresholdMs: number): NetworkSummary;
+export declare function createMetricsStore(options: MetricsStoreOptions): MetricsStore;

package/dist/core/metricsStore.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMetricsStore = exports.calculateSummary = void 0;
+function createEmptySummary() {
+    return {
+        requestCount: 0,
+        errorRate: 0,
+        timeoutRate: 0,
+        slowRequestRate: 0,
+        medianDurationMs: 0,
+        p95DurationMs: 0,
+        affectedEndpointRatio: 0,
+    };
+}
+function percentile(sortedValues, percentileValue) {
+    var index;
+    if (sortedValues.length === 0) {
+        return 0;
+    }
+    index = Math.ceil((percentileValue / 100) * sortedValues.length) - 1;
+    if (index < 0) {
+        index = 0;
+    }
+    return sortedValues[index];
+}
+function calculateSummary(events, slowRequestThresholdMs) {
+    var total = events.length;
+    var errors = 0;
+    var timeouts = 0;
+    var slow = 0;
+    var durations = [];
+    var endpoints = {};
+    var affectedEndpoints = {};
+    var endpointCount = 0;
+    var affectedEndpointCount = 0;
+    var i;
+    var event;
+    var route;
+    var affected;
+    if (total === 0) {
+        return createEmptySummary();
+    }
+    for (i = 0; i < total; i += 1) {
+        event = events[i];
+        route = event.normalizedRoute;
+        affected = false;
+        durations.push(event.durationMs);
+        if (!event.success) {
+            errors += 1;
+            affected = true;
+        }
+        if (event.timedOut) {
+            timeouts += 1;
+            affected = true;
+        }
+        if (event.durationMs >= slowRequestThresholdMs) {
+            slow += 1;
+            affected = true;
+        }
+        if (!endpoints[route]) {
+            endpoints[route] = true;
+            endpointCount += 1;
+        }
+        if (affected && !affectedEndpoints[route]) {
+            affectedEndpoints[route] = true;
+            affectedEndpointCount += 1;
+        }
+    }
+    durations.sort(function (a, b) {
+        return a - b;
+    });
+    return {
+        requestCount: total,
+        errorRate: errors / total,
+        timeoutRate: timeouts / total,
+        slowRequestRate: slow / total,
+        medianDurationMs: percentile(durations, 50),
+        p95DurationMs: percentile(durations, 95),
+        affectedEndpointRatio: endpointCount === 0 ? 0 : affectedEndpointCount / endpointCount,
+    };
+}
+exports.calculateSummary = calculateSummary;
+function createMetricsStore(options) {
+    var events = [];
+    return {
+        add: function add(event) {
+            events.push(event);
+            while (events.length > options.maxSamples) {
+                events.shift();
+            }
+            return calculateSummary(events, options.slowRequestThresholdMs);
+        },
+        getEvents: function getEvents() {
+            return events.slice();
+        },
+        getSummary: function getSummary() {
+            return calculateSummary(events, options.slowRequestThresholdMs);
+        },
+        clear: function clear() {
+            events = [];
+        },
+    };
+}
+exports.createMetricsStore = createMetricsStore;

package/dist/core/routeNormalizer.d.ts

@@ -0,0 +1,2 @@
+import { RouteNormalizer } from './types';
+export declare const defaultRouteNormalizer: RouteNormalizer;

package/dist/core/routeNormalizer.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRouteNormalizer = void 0;
+function stripQueryAndHash(value) {
+    var withoutHash = value.split('#')[0];
+    return withoutHash.split('?')[0];
+}
+function extractPath(value) {
+    var clean = stripQueryAndHash(value || '');
+    var protocolIndex = clean.indexOf('://');
+    var pathStart;
+    if (protocolIndex >= 0) {
+        pathStart = clean.indexOf('/', protocolIndex + 3);
+        return pathStart >= 0 ? clean.substring(pathStart) : '/';
+    }
+    if (clean.indexOf('//') === 0) {
+        pathStart = clean.indexOf('/', 2);
+        return pathStart >= 0 ? clean.substring(pathStart) : '/';
+    }
+    return clean || '/';
+}
+function looksLikeId(segment) {
+    if (/^\d+$/.test(segment)) {
+        return true;
+    }
+    if (/^[0-9a-fA-F]{8,}$/.test(segment)) {
+        return true;
+    }
+    if (/^[0-9a-fA-F-]{16,}$/.test(segment) && segment.indexOf('-') >= 0) {
+        return true;
+    }
+    return false;
+}
+var defaultRouteNormalizer = function defaultRouteNormalizer(url) {
+    var path = extractPath(url);
+    var parts = path.split('/');
+    var normalized = [];
+    var i;
+    var part;
+    for (i = 0; i < parts.length; i += 1) {
+        part = parts[i];
+        if (part === '') {
+            if (i === 0) {
+                normalized.push('');
+            }
+            continue;
+        }
+        normalized.push(looksLikeId(part) ? ':id' : part);
+    }
+    path = normalized.join('/');
+    return path.charAt(0) === '/' ? path : '/' + path;
+};
+exports.defaultRouteNormalizer = defaultRouteNormalizer;

package/dist/core/ruleEngine.d.ts

@@ -0,0 +1,6 @@
+import { NetworkDiagnosis, NetworkRequestEvent } from './types';
+export type RuleEngineOptions = {
+    minimumSamplesToDiagnose: number;
+    slowRequestThresholdMs: number;
+};
+export declare function diagnoseNetwork(events: NetworkRequestEvent[], options: RuleEngineOptions): NetworkDiagnosis;

package/dist/core/ruleEngine.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnoseNetwork = void 0;
+var metricsStore_1 = require("./metricsStore");
+function countServerErrors(events) {
+    var count = 0;
+    var i;
+    var status;
+    for (i = 0; i < events.length; i += 1) {
+        status = events[i].status;
+        if (typeof status === 'number' && status >= 500) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function countSlowRoutes(events, slowRequestThresholdMs) {
+    var routes = {};
+    var count = 0;
+    var i;
+    var route;
+    for (i = 0; i < events.length; i += 1) {
+        if (events[i].durationMs >= slowRequestThresholdMs) {
+            route = events[i].normalizedRoute;
+            if (!routes[route]) {
+                routes[route] = true;
+                count += 1;
+            }
+        }
+    }
+    return count;
+}
+function countRoutes(events) {
+    var routes = {};
+    var count = 0;
+    var i;
+    var route;
+    for (i = 0; i < events.length; i += 1) {
+        route = events[i].normalizedRoute;
+        if (!routes[route]) {
+            routes[route] = true;
+            count += 1;
+        }
+    }
+    return count;
+}
+function buildDiagnosis(status, probableCause, confidenceLevel, reasons, events, slowRequestThresholdMs) {
+    return {
+        status: status,
+        probableCause: probableCause,
+        confidenceLevel: confidenceLevel,
+        reasons: reasons,
+        summary: (0, metricsStore_1.calculateSummary)(events, slowRequestThresholdMs),
+    };
+}
+function diagnoseNetwork(events, options) {
+    var summary = (0, metricsStore_1.calculateSummary)(events, options.slowRequestThresholdMs);
+    var serverErrorRate;
+    var slowRouteCount;
+    var routeCount;
+    if (summary.requestCount < options.minimumSamplesToDiagnose) {
+        return buildDiagnosis('unknown', 'unknown', 'low', ['Not enough samples to diagnose network communication.'], events, options.slowRequestThresholdMs);
+    }
+    serverErrorRate = countServerErrors(events) / summary.requestCount;
+    slowRouteCount = countSlowRoutes(events, options.slowRequestThresholdMs);
+    routeCount = countRoutes(events);
+    if (summary.timeoutRate >= 0.5) {
+        return buildDiagnosis('poor', 'client-network', 'high', ['Many requests are timing out.'], events, options.slowRequestThresholdMs);
+    }
+    if (serverErrorRate >= 0.4) {
+        return buildDiagnosis('poor', 'backend', 'high', ['Many requests are failing with 5xx server errors.'], events, options.slowRequestThresholdMs);
+    }
+    if (summary.slowRequestRate >= 0.5 && summary.affectedEndpointRatio >= 0.5 && slowRouteCount > 1) {
+        return buildDiagnosis(summary.slowRequestRate >= 0.75 ? 'poor' : 'degraded', 'infrastructure', 'medium', ['Several different endpoints are slow in the current sample window.'], events, options.slowRequestThresholdMs);
+    }
+    if (summary.slowRequestRate >= 0.3 && slowRouteCount === 1 && routeCount > 1) {
+        return buildDiagnosis('degraded', 'specific-endpoint', 'medium', ['Only one endpoint concentrates slow requests.'], events, options.slowRequestThresholdMs);
+    }
+    if (summary.errorRate >= 0.3) {
+        return buildDiagnosis('degraded', 'unknown', 'medium', ['A relevant share of requests is failing.'], events, options.slowRequestThresholdMs);
+    }
+    return buildDiagnosis('good', 'unknown', 'high', ['Most requests in the current sample window are healthy.'], events, options.slowRequestThresholdMs);
+}
+exports.diagnoseNetwork = diagnoseNetwork;

package/dist/core/types.d.ts

@@ -0,0 +1,73 @@
+export type NetworkRequestSource = 'fetch' | 'axios';
+export type NetworkErrorType = 'timeout' | 'aborted' | 'network' | 'http-client' | 'http-server' | 'unknown';
+export type NetworkRequestEvent = {
+    requestId: string;
+    source: NetworkRequestSource;
+    method: string;
+    url?: string;
+    route: string;
+    normalizedRoute: string;
+    startedAt: number;
+    finishedAt: number;
+    durationMs: number;
+    status?: number;
+    success: boolean;
+    errorType?: NetworkErrorType;
+    timedOut: boolean;
+    aborted: boolean;
+};
+export type NetworkStatus = 'good' | 'degraded' | 'poor' | 'offline' | 'unknown';
+export type ProbableCause = 'client-network' | 'specific-endpoint' | 'backend' | 'infrastructure' | 'frontend-or-device' | 'unknown';
+export type ConfidenceLevel = 'low' | 'medium' | 'high';
+export type NetworkSummary = {
+    requestCount: number;
+    errorRate: number;
+    timeoutRate: number;
+    slowRequestRate: number;
+    medianDurationMs: number;
+    p95DurationMs: number;
+    affectedEndpointRatio: number;
+};
+export type NetworkDiagnosis = {
+    status: NetworkStatus;
+    probableCause: ProbableCause;
+    confidenceLevel: ConfidenceLevel;
+    reasons: string[];
+    summary: NetworkSummary;
+};
+export type RouteNormalizer = (url: string) => string;
+export type NetworkListenerOptions = {
+    slowRequestThresholdMs?: number;
+    maxSamples?: number;
+    minimumSamplesToDiagnose?: number;
+    routeNormalizer?: RouteNormalizer;
+    timeoutThresholdMs?: number;
+};
+export type NetworkListener = {
+    start: () => void;
+    stop: () => void;
+    subscribe: (subscriber: NetworkDiagnosisSubscriber) => Unsubscribe;
+    getSnapshot: () => NetworkDiagnosis;
+    record: (event: NetworkRequestEvent) => void;
+    installFetch: (target?: FetchTarget) => Uninstall;
+    installAxios: (axiosInstance: AxiosLike) => Uninstall;
+};
+export type NetworkDiagnosisSubscriber = (diagnosis: NetworkDiagnosis) => void;
+export type Unsubscribe = () => void;
+export type Uninstall = () => void;
+export type FetchTarget = {
+    fetch?: FetchLike;
+};
+export type FetchLike = {
+    apply: (thisArg: any, args: IArguments | any[]) => Promise<any>;
+};
+export type AxiosLike = {
+    interceptors: {
+        request: AxiosInterceptorManager;
+        response: AxiosInterceptorManager;
+    };
+};
+export type AxiosInterceptorManager = {
+    use: (onFulfilled?: any, onRejected?: any) => number;
+    eject: (id: number) => void;
+};

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createNetworkListener } from './core/createNetworkListener';
+export { defaultRouteNormalizer } from './core/routeNormalizer';
+export { createMetricsStore, calculateSummary } from './core/metricsStore';
+export { diagnoseNetwork } from './core/ruleEngine';
+export * from './core/types';

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnoseNetwork = exports.calculateSummary = exports.createMetricsStore = exports.defaultRouteNormalizer = exports.createNetworkListener = void 0;
+var createNetworkListener_1 = require("./core/createNetworkListener");
+Object.defineProperty(exports, "createNetworkListener", { enumerable: true, get: function () { return createNetworkListener_1.createNetworkListener; } });
+var routeNormalizer_1 = require("./core/routeNormalizer");
+Object.defineProperty(exports, "defaultRouteNormalizer", { enumerable: true, get: function () { return routeNormalizer_1.defaultRouteNormalizer; } });
+var metricsStore_1 = require("./core/metricsStore");
+Object.defineProperty(exports, "createMetricsStore", { enumerable: true, get: function () { return metricsStore_1.createMetricsStore; } });
+Object.defineProperty(exports, "calculateSummary", { enumerable: true, get: function () { return metricsStore_1.calculateSummary; } });
+var ruleEngine_1 = require("./core/ruleEngine");
+Object.defineProperty(exports, "diagnoseNetwork", { enumerable: true, get: function () { return ruleEngine_1.diagnoseNetwork; } });
+__exportStar(require("./core/types"), exports);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@henrique-olivier/network-listener",
+  "version": "0.1.0",
+  "description": "POC de uma biblioteca leve para observar requisicoes HTTP e gerar diagnosticos provaveis.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "jest --runInBand"
+  },
+  "keywords": [
+    "network",
+    "observability",
+    "frontend",
+    "fetch",
+    "axios"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "26.0.24",
+    "jest": "26.6.3",
+    "ts-jest": "26.5.6",
+    "typescript": "4.9.5"
+  }
+}