@henrique-olivier/network-listener 0.1.0 → 0.1.1

package/README.md

@@ -73,7 +73,20 @@ Exemplo de retorno:
     medianDurationMs: 700,
     p95DurationMs: 2300,
     affectedEndpointRatio: 0.2
-  }
+  },
+  affectedEndpoints: [
+    {
+      normalizedRoute: '/api/reports',
+      requestCount: 7,
+      errorRate: 0,
+      timeoutRate: 0,
+      slowRequestRate: 1,
+      medianDurationMs: 1800,
+      p95DurationMs: 2300,
+      statusCodes: [],
+      issueTypes: ['slow']
+    }
+  ]
 }
 ```
 

package/dist/core/ruleEngine.js

@@ -44,6 +44,118 @@ function countRoutes(events) {
     }
     return count;
 }
+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 pushUniqueString(values, value) {
+    if (values.indexOf(value) < 0) {
+        values.push(value);
+    }
+}
+function pushUniqueNumber(values, value) {
+    if (values.indexOf(value) < 0) {
+        values.push(value);
+    }
+}
+function getEndpointIssueType(event, slowRequestThresholdMs) {
+    if (event.timedOut) {
+        return 'timeout';
+    }
+    if (event.durationMs >= slowRequestThresholdMs) {
+        return 'slow';
+    }
+    if (event.errorType) {
+        return event.errorType;
+    }
+    if (typeof event.status === 'number' && event.status >= 500) {
+        return 'http-server';
+    }
+    if (typeof event.status === 'number' && event.status >= 400) {
+        return 'http-client';
+    }
+    return undefined;
+}
+function buildAffectedEndpoints(events, slowRequestThresholdMs) {
+    var grouped = {};
+    var result = [];
+    var i;
+    var event;
+    var route;
+    var item;
+    var issueType;
+    for (i = 0; i < events.length; i += 1) {
+        event = events[i];
+        route = event.normalizedRoute;
+        if (!grouped[route]) {
+            grouped[route] = {
+                normalizedRoute: route,
+                requestCount: 0,
+                errors: 0,
+                timeouts: 0,
+                slowRequests: 0,
+                durations: [],
+                statusCodes: [],
+                issueTypes: [],
+            };
+        }
+        item = grouped[route];
+        item.requestCount += 1;
+        item.durations.push(event.durationMs);
+        if (!event.success) {
+            item.errors += 1;
+        }
+        if (event.timedOut) {
+            item.timeouts += 1;
+        }
+        if (event.durationMs >= slowRequestThresholdMs) {
+            item.slowRequests += 1;
+        }
+        if (typeof event.status === 'number' && event.status >= 400) {
+            pushUniqueNumber(item.statusCodes, event.status);
+        }
+        issueType = getEndpointIssueType(event, slowRequestThresholdMs);
+        if (issueType) {
+            pushUniqueString(item.issueTypes, issueType);
+        }
+    }
+    for (route in grouped) {
+        if (Object.prototype.hasOwnProperty.call(grouped, route)) {
+            item = grouped[route];
+            if (item.issueTypes.length > 0) {
+                item.durations.sort(function (a, b) {
+                    return a - b;
+                });
+                result.push({
+                    normalizedRoute: item.normalizedRoute,
+                    requestCount: item.requestCount,
+                    errorRate: item.errors / item.requestCount,
+                    timeoutRate: item.timeouts / item.requestCount,
+                    slowRequestRate: item.slowRequests / item.requestCount,
+                    medianDurationMs: percentile(item.durations, 50),
+                    p95DurationMs: percentile(item.durations, 95),
+                    statusCodes: item.statusCodes.sort(function (a, b) {
+                        return a - b;
+                    }),
+                    issueTypes: item.issueTypes,
+                });
+            }
+        }
+    }
+    result.sort(function (a, b) {
+        var aScore = a.errorRate + a.timeoutRate + a.slowRequestRate;
+        var bScore = b.errorRate + b.timeoutRate + b.slowRequestRate;
+        return bScore - aScore;
+    });
+    return result;
+}
 function buildDiagnosis(status, probableCause, confidenceLevel, reasons, events, slowRequestThresholdMs) {
     return {
         status: status,
@@ -51,6 +163,7 @@ function buildDiagnosis(status, probableCause, confidenceLevel, reasons, events,
         confidenceLevel: confidenceLevel,
         reasons: reasons,
         summary: (0, metricsStore_1.calculateSummary)(events, slowRequestThresholdMs),
+        affectedEndpoints: buildAffectedEndpoints(events, slowRequestThresholdMs),
     };
 }
 function diagnoseNetwork(events, options) {

package/dist/core/types.d.ts

@@ -28,12 +28,25 @@ export type NetworkSummary = {
     p95DurationMs: number;
     affectedEndpointRatio: number;
 };
+export type EndpointIssueType = 'slow' | 'timeout' | 'http-client' | 'http-server' | 'network' | 'aborted' | 'unknown';
+export type EndpointDiagnosis = {
+    normalizedRoute: string;
+    requestCount: number;
+    errorRate: number;
+    timeoutRate: number;
+    slowRequestRate: number;
+    medianDurationMs: number;
+    p95DurationMs: number;
+    statusCodes: number[];
+    issueTypes: EndpointIssueType[];
+};
 export type NetworkDiagnosis = {
     status: NetworkStatus;
     probableCause: ProbableCause;
     confidenceLevel: ConfidenceLevel;
     reasons: string[];
     summary: NetworkSummary;
+    affectedEndpoints: EndpointDiagnosis[];
 };
 export type RouteNormalizer = (url: string) => string;
 export type NetworkListenerOptions = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henrique-olivier/network-listener",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "POC de uma biblioteca leve para observar requisicoes HTTP e gerar diagnosticos provaveis.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",