midline-agent 0.3.0 → 0.4.1

package/dist/browser/vitals.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observeVitals = observeVitals;
+/** web.dev thresholds: at or under the first is good, over the second is poor. */
+const THRESHOLDS = {
+    LCP: [2500, 4000],
+    INP: [200, 500],
+    CLS: [0.1, 0.25],
+    FCP: [1800, 3000],
+    TTFB: [800, 1800],
+};
+const rate = (name, value) => value <= THRESHOLDS[name][0] ? "good" : value <= THRESHOLDS[name][1] ? "needs-improvement" : "poor";
+/**
+ * Core Web Vitals without a dependency, measured the way the web-vitals library
+ * does and reported once, when the page is first hidden (the last moment a
+ * report reliably gets out). Browsers that don't expose an entry type simply
+ * omit that metric: Safari has no LCP, INP or CLS.
+ */
+function observeVitals(win, onReport) {
+    const Observer = win.PerformanceObserver;
+    const supported = Observer?.supportedEntryTypes ?? [];
+    const perf = win.performance;
+    const doc = win.document;
+    const values = {};
+    const observers = [];
+    let activationStart = 0;
+    let navigationType;
+    try {
+        const navigation = perf?.getEntriesByType?.("navigation")?.[0];
+        if (navigation) {
+            activationStart = navigation.activationStart ?? 0;
+            navigationType = navigation.type;
+            if (typeof navigation.responseStart === "number" && navigation.responseStart > 0) {
+                values.TTFB = Math.max(0, navigation.responseStart - activationStart);
+            }
+        }
+    }
+    catch {
+        // no navigation timing
+    }
+    const observe = (type, handle, extra = {}) => {
+        if (!Observer || !supported.includes(type))
+            return;
+        try {
+            const observer = new Observer((list) => handle(list.getEntries()));
+            observer.observe({ type, buffered: true, ...extra });
+            observers.push({ observer, handle });
+        }
+        catch {
+            // unsupported option in this browser
+        }
+    };
+    observe("paint", (entries) => {
+        for (const entry of entries) {
+            if (entry.name === "first-contentful-paint")
+                values.FCP = Math.max(0, entry.startTime - activationStart);
+        }
+    });
+    observe("largest-contentful-paint", (entries) => {
+        const last = entries[entries.length - 1];
+        if (last)
+            values.LCP = Math.max(0, last.startTime - activationStart);
+    });
+    // CLS is the largest session window: shifts less than 1s apart, at most 5s long.
+    let windowValue = 0;
+    let windowStart = 0;
+    let windowLast = 0;
+    observe("layout-shift", (entries) => {
+        for (const entry of entries) {
+            if (entry.hadRecentInput || typeof entry.value !== "number")
+                continue;
+            if (windowValue && entry.startTime - windowLast < 1000 && entry.startTime - windowStart < 5000) {
+                windowValue += entry.value;
+            }
+            else {
+                windowValue = entry.value;
+                windowStart = entry.startTime;
+            }
+            windowLast = entry.startTime;
+            values.CLS = Math.max(values.CLS ?? 0, windowValue);
+        }
+    });
+    // INP: the slowest interaction, or near the 98th percentile on busy pages.
+    const interactions = new Map();
+    const recordInteractions = (entries) => {
+        for (const entry of entries) {
+            if (!entry.interactionId)
+                continue;
+            interactions.set(entry.interactionId, Math.max(interactions.get(entry.interactionId) ?? 0, entry.duration));
+        }
+    };
+    observe("event", recordInteractions, { durationThreshold: 40 });
+    observe("first-input", recordInteractions);
+    let reported = false;
+    const report = () => {
+        if (reported)
+            return;
+        reported = true;
+        for (const { observer, handle } of observers) {
+            try {
+                handle(observer.takeRecords());
+                observer.disconnect();
+            }
+            catch {
+                // already disconnected
+            }
+        }
+        if (interactions.size) {
+            const durations = [...interactions.values()].sort((a, b) => b - a);
+            values.INP = durations[Math.min(durations.length - 1, Math.floor(durations.length / 50))];
+        }
+        const vitals = {};
+        for (const name of Object.keys(values)) {
+            const raw = values[name];
+            if (typeof raw !== "number" || !Number.isFinite(raw))
+                continue;
+            const value = name === "CLS" ? Math.round(raw * 10000) / 10000 : Math.round(raw);
+            vitals[name] = { value, rating: rate(name, value) };
+        }
+        if (Object.keys(vitals).length)
+            onReport({ vitals, navigationType });
+    };
+    const onVisibility = () => {
+        if (doc?.visibilityState === "hidden")
+            report();
+    };
+    doc?.addEventListener("visibilitychange", onVisibility, true);
+    win.addEventListener("pagehide", report, true);
+    return () => {
+        doc?.removeEventListener("visibilitychange", onVisibility, true);
+        win.removeEventListener("pagehide", report, true);
+        for (const { observer } of observers)
+            observer.disconnect();
+    };
+}

package/dist/config.d.ts

@@ -1,6 +1,5 @@
 import { CaInput, CaptureOptions, MidlineConfig } from "./types";
 export declare const DEFAULT_ENDPOINT = "https://api.usemidline.com";
-export declare const INGEST_PATH = "/api/api-monitor/events";
 /** A setting that cannot work as given. Thrown at construction, never while serving traffic. */
 export declare class ConfigError extends Error {
     constructor(message: string);
@@ -15,8 +14,8 @@ export interface ResolvedCapture {
 export interface ResolvedConfig {
     apiKey: string;
     serviceName?: string;
-    ingestUrl: URL;
-    batchUrl: URL;
+    /** The Midline server's origin; the ingest gateway lives at `${socketOrigin}/ingest`. */
+    socketOrigin: URL;
     /** Full trust store for the Midline endpoint, or undefined for Node's default. */
     ca?: Array<string | Buffer>;
     hasCustomCa: boolean;
@@ -43,12 +42,14 @@ export declare function envFlag(name: string): boolean | undefined;
 export declare function envInt(name: string): number | undefined;
 export declare function isLoopback(hostname: string): boolean;
 /**
- * Turns whatever the user configured into the ingest URL.
- *
+ * Turns whatever the user configured into the Midline server's origin — the
+ * agent connects to `${origin}/ingest` over socket.io, so only the origin
+ * matters now. Tolerates an old-style full ingest URL some existing
+ * `MIDLINE_ENDPOINT` values still carry (from before the socket.io transport):
  * `https://api.usemidline.com`, `https://api.usemidline.com/api/api-monitor/events`
- * and `https://gateway.internal/midline` all work; the last is treated as a prefix.
+ * and `https://gateway.internal/midline` all resolve to the same origin.
  */
-export declare function resolveIngestUrl(endpoint: string): URL;
+export declare function resolveEndpointOrigin(endpoint: string): URL;
 /**
  * Loads extra CAs. Every entry must contain at least one parseable certificate, so a
  * typo in a path fails loudly at startup instead of silently trusting nothing.

package/dist/config.js

@@ -33,12 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigError = exports.INGEST_PATH = exports.DEFAULT_ENDPOINT = void 0;
+exports.ConfigError = exports.DEFAULT_ENDPOINT = void 0;
 exports.env = env;
 exports.envFlag = envFlag;
 exports.envInt = envInt;
 exports.isLoopback = isLoopback;
-exports.resolveIngestUrl = resolveIngestUrl;
+exports.resolveEndpointOrigin = resolveEndpointOrigin;
 exports.loadCa = loadCa;
 exports.trustStore = trustStore;
 exports.resolveCapture = resolveCapture;
@@ -47,7 +47,6 @@ const fs_1 = require("fs");
 const crypto_1 = require("crypto");
 const tls = __importStar(require("tls"));
 exports.DEFAULT_ENDPOINT = "https://api.usemidline.com";
-exports.INGEST_PATH = "/api/api-monitor/events";
 /** A setting that cannot work as given. Thrown at construction, never while serving traffic. */
 class ConfigError extends Error {
     constructor(message) {
@@ -88,12 +87,14 @@ function isLoopback(hostname) {
         /^127(\.\d{1,3}){3}$/.test(host));
 }
 /**
- * Turns whatever the user configured into the ingest URL.
- *
+ * Turns whatever the user configured into the Midline server's origin — the
+ * agent connects to `${origin}/ingest` over socket.io, so only the origin
+ * matters now. Tolerates an old-style full ingest URL some existing
+ * `MIDLINE_ENDPOINT` values still carry (from before the socket.io transport):
  * `https://api.usemidline.com`, `https://api.usemidline.com/api/api-monitor/events`
- * and `https://gateway.internal/midline` all work; the last is treated as a prefix.
+ * and `https://gateway.internal/midline` all resolve to the same origin.
  */
-function resolveIngestUrl(endpoint) {
+function resolveEndpointOrigin(endpoint) {
     let url;
     try {
         url = new URL(endpoint);
@@ -111,19 +112,7 @@ function resolveIngestUrl(endpoint) {
     if (url.username || url.password) {
         throw new ConfigError("endpoint must not contain credentials; pass the key as apiKey");
     }
-    url.search = "";
-    url.hash = "";
-    const path = url.pathname.replace(/\/+$/, "");
-    if (path.endsWith(`${exports.INGEST_PATH}/batch`)) {
-        url.pathname = path.slice(0, -"/batch".length);
-    }
-    else if (path.endsWith(exports.INGEST_PATH)) {
-        url.pathname = path;
-    }
-    else {
-        url.pathname = `${path}${exports.INGEST_PATH}`;
-    }
-    return url;
+    return new URL(url.origin);
 }
 /**
  * Loads extra CAs. Every entry must contain at least one parseable certificate, so a
@@ -197,16 +186,15 @@ function resolveCapture(capture) {
 }
 function resolveConfig(config) {
     const apiKey = (config.apiKey ?? env("MIDLINE_API_KEY") ?? "").trim();
-    const ingestUrl = resolveIngestUrl(config.endpoint || env("MIDLINE_ENDPOINT") || exports.DEFAULT_ENDPOINT);
+    const socketOrigin = resolveEndpointOrigin(config.endpoint || env("MIDLINE_ENDPOINT") || exports.DEFAULT_ENDPOINT);
     const extraCa = loadCa(config.ca ?? env("MIDLINE_CUSTOM_CA"), "ca / MIDLINE_CUSTOM_CA");
-    if (extraCa && ingestUrl.protocol !== "https:") {
+    if (extraCa && socketOrigin.protocol !== "https:") {
         throw new ConfigError("ca / MIDLINE_CUSTOM_CA is set but the endpoint is not https://");
     }
     return {
         apiKey,
         serviceName: config.serviceName ?? env("MIDLINE_SERVICE_NAME"),
-        ingestUrl,
-        batchUrl: new URL(`${ingestUrl.pathname}/batch`, ingestUrl),
+        socketOrigin,
         ca: trustStore(extraCa),
         hasCustomCa: Boolean(extraCa),
         environment: config.environment ?? env("MIDLINE_ENVIRONMENT"),