midline-agent 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to `midline-agent`, compiled from git history. Dates reflect commit dates, newest first.
+
+## 2026-09-17
+- feat: `midline-agent/browser` captures pageviews — on load and on every SPA route change — as the
+  basis for visitor counting and funnel views in the Midline dashboard (0.5.0)
+- feat: every browser event carries a top-level `sessionId`, stable for the tab's lifetime
+
+## 2026-09-14
+- chore: bump version to 0.4.1
+- chore: add socket.io dependencies and update configuration
+
+## 2026-09-13
+- feat: midline-agent/browser, a browser SDK in the same package (0.4.0)
+- docs: console lines show on the Terminal page, and 5xx responses group into Issues
+- docs: add README for midline-agent SDK
+- feat!: midline-agent 0.2.0 — verified TLS only, proxy mode, safe delivery (breaking)
+- feat: add midline-agent package with core types, configuration, and agent implementation
+
+## 2026-09-12
+- first commit
+- feat: add midline-agent package for event monitoring and reporting
+- Update agent API endpoint to api.usemidline.com
+- docs: expand README with detailed NestJS, Node.js, and Express.js setup guides

package/README.md

@@ -1,6 +1,6 @@
 # midline-agent
 
-**The Node.js SDK for Midline** — request and error monitoring with security and threat detection.
+**SDK for Midline** — request and error monitoring with security and threat detection.
 It also ships **`midline-agent/browser`** for web apps: see [Browser apps](#browser-apps).
 
 Midline itself is not tied to Node. Every event lands on the same stream through a plain JSON
@@ -378,9 +378,10 @@ app.get("/x", (req, res) => { logger.info({ requestId: getRequestContext(req)?.r
 ## Browser apps
 
 `midline-agent/browser` monitors a web app from the page: uncaught errors and unhandled rejections,
-failed `fetch` and `XMLHttpRequest` calls, Web Vitals (LCP, INP, CLS, FCP, TTFB) and, if you ask,
-console output. It has no dependencies, no Node code, and works under React, Vue, Angular, Svelte,
-Next.js or no framework at all, because it instruments the page rather than a framework.
+failed `fetch` and `XMLHttpRequest` calls, Web Vitals (LCP, INP, CLS, FCP, TTFB), pageviews for
+visitor counting and funnel views, and, if you ask, console output. It has no dependencies, no Node
+code, and works under React, Vue, Angular, Svelte, Next.js or no framework at all, because it
+instruments the page rather than a framework.
 
 ```ts
 import * as Midline from "midline-agent/browser";
@@ -424,6 +425,7 @@ the browser will block the call's preflight.
 | `captureErrors` | `true` | Uncaught errors and unhandled rejections. |
 | `captureRequests` | `"failed"` | `"failed"` (4xx, 5xx, network errors), `"all"`, or `false`. Every call is a breadcrumb either way. |
 | `captureWebVitals` | `true` | Reported once, when the page is first hidden. |
+| `capturePageviews` | `true` | A `pageview` event on load and on every SPA route change (`pushState`/`replaceState`/`popstate`), tagged with a per-tab `sessionId` — what the dashboard's visitor and funnel views are built from. |
 | `captureConsole` | `false` | `true` for `error` and `warn`, or a list of levels. Lines appear on the Terminal page. Opt-in because wrapped console calls show the SDK as their source in devtools. |
 | `tracePropagationTargets` | same origin | Strings match as URL prefixes (or path prefixes starting with `/`); RegExps match the full URL. |
 | `ignoreErrors`, `ignoreUrls` | `[]` | Strings match as substrings. |
@@ -446,7 +448,7 @@ No bundler? Load the ES module build directly:
 
 ```html
 <script type="module">
-  import * as Midline from "https://cdn.jsdelivr.net/npm/midline-agent@0.4.0/dist/esm/browser/index.js";
+  import * as Midline from "https://cdn.jsdelivr.net/npm/midline-agent@0.5.0/dist/esm/browser/index.js";
   Midline.init({ apiKey: "pk_…", service: "web" });
 </script>
 ```
@@ -476,8 +478,8 @@ Authenticate with the `X-API-Key` header. An `apiKey` field in the body is still
 
 | Field | Required | Notes |
 | --- | --- | --- |
-| `eventType` | yes | `request` · `error` · `security` · `performance` · `custom` |
-| `route` | yes | Path only, e.g. `/v1/charges` |
+| `eventType` | yes | `request` · `error` · `security` · `performance` · `pageview` · `custom` |
+| `route` | yes | Path only, e.g. `/v1/charges`. For `pageview`, the page path. |
 | `method` | no | HTTP method |
 | `statusCode` | no | 100–599 |
 | `responseTime` | no | Milliseconds |
@@ -486,6 +488,7 @@ Authenticate with the `X-API-Key` header. An `apiKey` field in the body is still
 | `service` / `environment` / `release` | no | Where it came from |
 | `timestamp` | no | ISO 8601; clamped to server time if implausibly far off |
 | `requestId` / `correlationId` / `traceId` | no | For joining events across services |
+| `sessionId` | no | A stable id for one visitor's session (e.g. a browser tab). Send the same value on every event from that session and Midline can build visitor counts and funnels from `pageview` events. Keep it opaque — never an email or a real user id. |
 | `payload` | no | Free-form context — error message, stack, captured request/response |
 | `metadata` | no | Free-form, e.g. SDK name and version |
 

package/dist/agent.d.ts

@@ -80,7 +80,15 @@ export declare class MidlineAgent {
     recordHttp(exchange: HttpExchange): void;
     private recordConsole;
     private takeConsoleToken;
-    /** Sends whatever is buffered now, ignoring backoff, and keeps the process alive until done. */
+    /**
+     * Sends whatever is buffered now, ignoring backoff.
+     *
+     * The transport's connection is always unref'd (telemetry alone must never
+     * keep an otherwise-idle process alive), so this relies on something else in
+     * the process keeping the event loop open until the await resolves — true for
+     * the overwhelmingly common case (a running server), not guaranteed for a
+     * bare script whose last statement is `await agent.flush()`.
+     */
     flush(): Promise<void>;
     /** Flushes with a deadline, then closes. For graceful shutdown. */
     shutdown(timeoutMs?: number): Promise<void>;

package/dist/agent.js

@@ -4,7 +4,7 @@ exports.MidlineAgent = exports.SDK_VERSION = void 0;
 const config_1 = require("./config");
 const console_1 = require("./console");
 const redact_1 = require("./redact");
-const transport_1 = require("./transport");
+const socket_transport_1 = require("./socket-transport");
 exports.SDK_VERSION = (() => {
     try {
         return require("../package.json").version;
@@ -104,15 +104,19 @@ class MidlineAgent {
             return;
         }
         this.config = resolved;
-        this.transport = new transport_1.Transport(resolved.ingestUrl, {
+        this.transport = new socket_transport_1.SocketTransport(resolved.socketOrigin, {
+            apiKey: resolved.apiKey,
             ca: resolved.ca,
             connectTimeoutMs: resolved.connectTimeoutMs,
             timeoutMs: resolved.timeoutMs,
+            reconnectionDelayMs: resolved.flushIntervalMs,
+            reconnectionDelayMaxMs: resolved.maxRetryDelayMs,
+            idleDisconnectMs: Math.max(5 * resolved.flushIntervalMs, 30000),
             userAgent: `midline-agent/${exports.SDK_VERSION} node/${process.version}`,
         });
         this.timer = setInterval(() => {
             this.consoleCapture?.flushPending();
-            void this.drain(false);
+            void this.drain();
         }, resolved.flushIntervalMs);
         // Telemetry must never be the reason a process refuses to exit.
         this.timer.unref?.();
@@ -212,7 +216,15 @@ class MidlineAgent {
         this.consoleTokens -= 1;
         return true;
     }
-    /** Sends whatever is buffered now, ignoring backoff, and keeps the process alive until done. */
+    /**
+     * Sends whatever is buffered now, ignoring backoff.
+     *
+     * The transport's connection is always unref'd (telemetry alone must never
+     * keep an otherwise-idle process alive), so this relies on something else in
+     * the process keeping the event loop open until the await resolves — true for
+     * the overwhelmingly common case (a running server), not guaranteed for a
+     * bare script whose last statement is `await agent.flush()`.
+     */
     async flush() {
         if (!this.active)
             return;
@@ -221,7 +233,7 @@ class MidlineAgent {
         if (this.drainPromise) {
             await this.drainPromise;
         }
-        await this.drain(true);
+        await this.drain();
     }
     /** Flushes with a deadline, then closes. For graceful shutdown. */
     async shutdown(timeoutMs = 5000) {
@@ -417,23 +429,23 @@ class MidlineAgent {
         }
         return batch;
     }
-    drain(keepProcessAlive) {
+    drain() {
         if (this.drainPromise)
             return this.drainPromise;
         if (!this.active || !this.queue.length || Date.now() < this.retryAfter) {
             return Promise.resolve();
         }
-        this.drainPromise = this.runDrain(keepProcessAlive).finally(() => {
+        this.drainPromise = this.runDrain().finally(() => {
             this.drainPromise = null;
         });
         return this.drainPromise;
     }
-    async runDrain(keepProcessAlive) {
+    async runDrain() {
         while (this.queue.length && this.active) {
             // Taken off the queue while in flight, so overflow trimming can't remove
             // events that are mid-send and then be confused about what was accepted.
             const batch = this.takeBatch();
-            const outcome = await this.send(batch, keepProcessAlive);
+            const outcome = await this.send(batch);
             if (outcome.kind === "ok") {
                 this.onSuccess();
                 continue;
@@ -454,7 +466,7 @@ class MidlineAgent {
                 }
                 else {
                     this.dropped += 1;
-                    this.report("http-413", "midline: the Midline server rejected an event as too large (HTTP 413); dropped it.");
+                    this.report("too-large", "midline: the Midline server rejected an event as too large; dropped it.");
                 }
                 continue;
             }
@@ -468,7 +480,7 @@ class MidlineAgent {
                 }
                 // One malformed event fails validation for the whole batch. Send them one
                 // at a time so it only costs that event.
-                const isolated = await this.sendIndividually(batch, keepProcessAlive);
+                const isolated = await this.sendIndividually(batch);
                 if (!isolated)
                     return;
                 continue;
@@ -479,16 +491,16 @@ class MidlineAgent {
         }
     }
     /** Returns false if delivery should stop for this drain. */
-    async sendIndividually(batch, keepProcessAlive) {
+    async sendIndividually(batch) {
         for (let index = 0; index < batch.length; index++) {
             if (this.consoleUnsupported && batch[index].wire.eventType === "console")
                 continue;
-            const outcome = await this.send([batch[index]], keepProcessAlive);
+            const outcome = await this.send([batch[index]]);
             if (outcome.kind === "ok") {
                 this.onSuccess();
             }
             else if (outcome.kind === "rejected" || outcome.kind === "tooLarge") {
-                const detail = outcome.kind === "rejected" ? outcome.detail : "HTTP 413";
+                const detail = outcome.kind === "rejected" ? outcome.detail : "too_large";
                 if (outcome.kind === "rejected" && this.refusedConsole(batch[index], detail))
                     continue;
                 this.dropped += 1;
@@ -506,53 +518,40 @@ class MidlineAgent {
         }
         return true;
     }
-    async send(batch, keepProcessAlive) {
-        const config = this.config;
-        const body = JSON.stringify({ events: batch.map((item) => item.wire) });
-        let result;
+    async send(batch) {
+        let ack;
         try {
-            result = await this.transport.post(config.batchUrl, body, { "x-api-key": config.apiKey }, keepProcessAlive);
+            ack = await this.transport.send(batch.map((item) => item.wire));
         }
         catch (err) {
             this.report(`transport:${errorCode(err)}`, this.describe(err, batch.length));
             return { kind: "retry" };
         }
-        const { status } = result;
-        if (status >= 200 && status < 300) {
-            // Servers that predate 401-on-bad-key answer 201 and count the rejects.
-            const summary = parseJson(result.body);
-            const failed = typeof summary?.failed === "number" ? summary.failed : 0;
-            if (failed >= batch.length && batch.length > 0) {
+        if (ack.ok) {
+            // Servers that predate 401-on-bad-key ack ok and count the rejects.
+            if (ack.rejected >= batch.length && batch.length > 0) {
                 this.log("error", "midline: the Midline server did not accept this API key. Monitoring is now off — retrying wouldn't help. Check apiKey / MIDLINE_API_KEY.");
                 return { kind: "stop" };
             }
-            if (failed > 0) {
-                this.dropped += failed;
-                this.report("partial", `midline: the Midline server rejected ${failed} of ${batch.length} events.`);
+            if (ack.rejected > 0) {
+                this.dropped += ack.rejected;
+                this.report("partial", `midline: the Midline server rejected ${ack.rejected} of ${batch.length} events.`);
             }
             return { kind: "ok" };
         }
-        if (status === 401 || status === 403) {
-            this.log("error", `midline: the Midline server rejected the API key (HTTP ${status}). ` +
+        if (ack.code === "unauthorized" || ack.code === "forbidden") {
+            this.log("error", `midline: the Midline server rejected the API key (${ack.code}). ` +
                 "Monitoring is now off — retrying wouldn't help. Check apiKey / MIDLINE_API_KEY.");
             return { kind: "stop" };
         }
-        if (status === 413) {
+        if (ack.code === "too_large") {
             return { kind: "tooLarge" };
         }
-        if (status === 408 || status === 429 || status >= 500) {
-            const retryAfterMs = parseRetryAfter(result.headers["retry-after"]);
-            this.report(`http-${status}`, `midline: the Midline server returned HTTP ${status}; events are buffered and will be retried.`);
-            return { kind: "retry", retryAfterMs };
+        if (ack.code === "rate_limited") {
+            this.report("rate_limited", `midline: the Midline server is rate-limiting this project; events are buffered and will be retried.`);
+            return { kind: "retry", retryAfterMs: ack.retryAfterMs };
         }
-        if (status >= 300 && status < 400) {
-            // Never followed: that would hand the API key to wherever the redirect points.
-            const location = String(result.headers.location ?? "").slice(0, 200);
-            this.report(`http-${status}`, `midline: the Midline endpoint redirected (HTTP ${status}${location ? ` to ${location}` : ""}). ` +
-                "Redirects are not followed; set MIDLINE_ENDPOINT to the final URL.");
-            return { kind: "retry" };
-        }
-        return { kind: "rejected", detail: `HTTP ${status}${serverMessage(result.body)}` };
+        return { kind: "rejected", detail: `${ack.code}: ${ack.message}` };
     }
     /**
      * True when a rejected event is a console line the server has no event type for,
@@ -582,7 +581,7 @@ class MidlineAgent {
     }
     describe(err, inFlight) {
         const config = this.config;
-        const origin = config.ingestUrl.origin;
+        const origin = config.socketOrigin.origin;
         const code = errorCode(err);
         const buffered = ` ${this.queue.length + inFlight} event(s) buffered; your application is unaffected.`;
         if (TLS_ERROR_REASONS[code] || code.startsWith("ERR_SSL") || code === "EPROTO") {
@@ -600,7 +599,7 @@ class MidlineAgent {
             return `midline: could not connect to ${origin} within ${config.connectTimeoutMs}ms; retrying with backoff.${buffered}`;
         }
         if (code === "ENOTFOUND" || code === "EAI_AGAIN") {
-            return `midline: cannot resolve ${config.ingestUrl.hostname} (${code}) — check MIDLINE_ENDPOINT and DNS; retrying with backoff.${buffered}`;
+            return `midline: cannot resolve ${config.socketOrigin.hostname} (${code}) — check MIDLINE_ENDPOINT and DNS; retrying with backoff.${buffered}`;
         }
         if (code === "ECONNREFUSED") {
             return `midline: ${origin} refused the connection; retrying with backoff.${buffered}`;
@@ -745,26 +744,3 @@ function errorCode(err) {
     const e = err;
     return String(e?.code ?? e?.cause?.code ?? e?.errno ?? e?.name ?? "");
 }
-function parseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}
-function serverMessage(body) {
-    const message = parseJson(body)?.message;
-    const text = Array.isArray(message) ? message.join("; ") : typeof message === "string" ? message : "";
-    return text ? `: ${text.slice(0, 300)}` : "";
-}
-function parseRetryAfter(header) {
-    const value = Array.isArray(header) ? header[0] : header;
-    if (!value)
-        return undefined;
-    const seconds = Number(value);
-    if (Number.isFinite(seconds))
-        return Math.max(0, seconds * 1000);
-    const date = Date.parse(value);
-    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
-}

package/dist/browser/client.d.ts

@@ -41,6 +41,7 @@ export declare class BrowserClient {
     private handleRequest;
     private handleConsole;
     private handleNavigation;
+    private handlePageview;
     private handleVitals;
     private propagation;
     private base;

package/dist/browser/client.js

@@ -26,7 +26,7 @@ const CONSOLE_SEVERITY = {
 /** Top-level fields the ingest API accepts from this SDK; it rejects the whole batch on anything else. */
 const WIRE_FIELDS = new Set([
     "eventType", "route", "method", "statusCode", "responseTime", "severity", "category", "timestamp",
-    "service", "environment", "release", "userAgent", "traceId", "spanId", "payload", "metadata",
+    "service", "environment", "release", "userAgent", "traceId", "spanId", "sessionId", "payload", "metadata",
 ]);
 class BrowserConfigError extends Error {
 }
@@ -81,6 +81,7 @@ function resolve(config) {
         captureRequests: config.captureRequests === undefined ? "failed" : config.captureRequests,
         consoleLevels: levels.filter((level) => level in CONSOLE_SEVERITY),
         captureWebVitals: config.captureWebVitals !== false,
+        capturePageviews: config.capturePageviews !== false,
         tracePropagationTargets: config.tracePropagationTargets,
         ignoreErrors: config.ignoreErrors ?? [],
         ignoreUrls: config.ignoreUrls ?? [],
@@ -169,6 +170,9 @@ class BrowserClient {
         if (this.config.captureWebVitals) {
             this.teardowns.push((0, vitals_js_1.observeVitals)(this.win, (report) => this.handleVitals(report)));
         }
+        if (this.config.capturePageviews) {
+            this.handlePageview(this.currentRoute(), this.win.document?.referrer || undefined);
+        }
         // Registered after the vitals listener so its event is queued before this sends.
         const onHide = () => {
             if (this.win.document?.visibilityState === "hidden")
@@ -327,6 +331,16 @@ class BrowserClient {
         // A new view is a new trace, so its API calls don't blur into the last one's.
         this.traceId = randomHex(16);
         this.breadcrumb("navigation", `${pathOf(from)} -> ${pathOf(to)}`);
+        // history.pushState/replaceState have already run by the time this fires, so
+        // win.location — and therefore currentRoute() — reflects the new view.
+        if (this.config.capturePageviews)
+            this.handlePageview(this.currentRoute());
+    }
+    handlePageview(route, referrer) {
+        const event = this.base("pageview", route, "low", "application");
+        if (referrer)
+            event.payload = { referrer: this.redactor.string(referrer, 2048) };
+        this.emit(event);
     }
     handleVitals(report) {
         const poor = Object.values(report.vitals).some((vital) => vital?.rating === "poor");
@@ -356,7 +370,6 @@ class BrowserClient {
             sdk: "midline-agent/browser",
             version: version_js_1.BROWSER_SDK_VERSION,
             runtime: "browser",
-            sessionId: this.sessionId,
             page: { url: this.pageUrl(), path: this.currentRoute() },
         };
         if (this.user && (this.user.id || this.user.username))
@@ -375,6 +388,7 @@ class BrowserClient {
             release: this.config.release,
             userAgent: clamp(nav?.userAgent, 512),
             traceId: this.traceId,
+            sessionId: this.sessionId,
             metadata,
         };
     }

package/dist/browser/types.d.ts

@@ -36,6 +36,12 @@ export interface MidlineBrowserConfig {
     captureConsole?: boolean | ConsoleLevel[];
     /** LCP, INP, CLS, FCP and TTFB, reported once when the page is first hidden. Default true. */
     captureWebVitals?: boolean;
+    /**
+     * A `pageview` event on load and on every SPA route change (history push/replace/popstate),
+     * carrying the same per-tab `sessionId` as every other event. This is what a visitor-count or
+     * funnel view in the Midline dashboard is built from. Default true.
+     */
+    capturePageviews?: boolean;
     /**
      * Requests that get a W3C `traceparent` header, so the backend's midline-agent
      * links its request to this page. Strings match as URL prefixes (or path prefixes
@@ -71,7 +77,7 @@ export interface MidlineBrowserConfig {
 }
 /** An event as it is sent to the ingest API. */
 export interface BrowserEvent {
-    eventType: "error" | "request" | "console" | "performance" | "custom";
+    eventType: "error" | "request" | "console" | "performance" | "pageview" | "custom";
     route: string;
     method?: string;
     statusCode?: number;
@@ -85,6 +91,8 @@ export interface BrowserEvent {
     userAgent?: string;
     traceId?: string;
     spanId?: string;
+    /** Stable for the tab's lifetime (sessionStorage-backed). Same value on every event this SDK sends. */
+    sessionId?: string;
     payload?: Record<string, unknown>;
     metadata: Record<string, unknown>;
 }

package/dist/browser/version.d.ts

@@ -1,2 +1,2 @@
 /** Kept in step with package.json by test/browser.test.js; a browser bundle can't read package.json. */
-export declare const BROWSER_SDK_VERSION = "0.4.0";
+export declare const BROWSER_SDK_VERSION = "0.5.0";

package/dist/browser/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BROWSER_SDK_VERSION = void 0;
 /** Kept in step with package.json by test/browser.test.js; a browser bundle can't read package.json. */
-exports.BROWSER_SDK_VERSION = "0.4.0";
+exports.BROWSER_SDK_VERSION = "0.5.0";

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"),

package/dist/esm/browser/client.js

@@ -21,7 +21,7 @@ const CONSOLE_SEVERITY = {
 /** Top-level fields the ingest API accepts from this SDK; it rejects the whole batch on anything else. */
 const WIRE_FIELDS = new Set([
     "eventType", "route", "method", "statusCode", "responseTime", "severity", "category", "timestamp",
-    "service", "environment", "release", "userAgent", "traceId", "spanId", "payload", "metadata",
+    "service", "environment", "release", "userAgent", "traceId", "spanId", "sessionId", "payload", "metadata",
 ]);
 export class BrowserConfigError extends Error {
 }
@@ -75,6 +75,7 @@ function resolve(config) {
         captureRequests: config.captureRequests === undefined ? "failed" : config.captureRequests,
         consoleLevels: levels.filter((level) => level in CONSOLE_SEVERITY),
         captureWebVitals: config.captureWebVitals !== false,
+        capturePageviews: config.capturePageviews !== false,
         tracePropagationTargets: config.tracePropagationTargets,
         ignoreErrors: config.ignoreErrors ?? [],
         ignoreUrls: config.ignoreUrls ?? [],
@@ -163,6 +164,9 @@ export class BrowserClient {
         if (this.config.captureWebVitals) {
             this.teardowns.push(observeVitals(this.win, (report) => this.handleVitals(report)));
         }
+        if (this.config.capturePageviews) {
+            this.handlePageview(this.currentRoute(), this.win.document?.referrer || undefined);
+        }
         // Registered after the vitals listener so its event is queued before this sends.
         const onHide = () => {
             if (this.win.document?.visibilityState === "hidden")
@@ -321,6 +325,16 @@ export class BrowserClient {
         // A new view is a new trace, so its API calls don't blur into the last one's.
         this.traceId = randomHex(16);
         this.breadcrumb("navigation", `${pathOf(from)} -> ${pathOf(to)}`);
+        // history.pushState/replaceState have already run by the time this fires, so
+        // win.location — and therefore currentRoute() — reflects the new view.
+        if (this.config.capturePageviews)
+            this.handlePageview(this.currentRoute());
+    }
+    handlePageview(route, referrer) {
+        const event = this.base("pageview", route, "low", "application");
+        if (referrer)
+            event.payload = { referrer: this.redactor.string(referrer, 2048) };
+        this.emit(event);
     }
     handleVitals(report) {
         const poor = Object.values(report.vitals).some((vital) => vital?.rating === "poor");
@@ -350,7 +364,6 @@ export class BrowserClient {
             sdk: "midline-agent/browser",
             version: BROWSER_SDK_VERSION,
             runtime: "browser",
-            sessionId: this.sessionId,
             page: { url: this.pageUrl(), path: this.currentRoute() },
         };
         if (this.user && (this.user.id || this.user.username))
@@ -369,6 +382,7 @@ export class BrowserClient {
             release: this.config.release,
             userAgent: clamp(nav?.userAgent, 512),
             traceId: this.traceId,
+            sessionId: this.sessionId,
             metadata,
         };
     }

package/dist/esm/browser/version.js

@@ -1,2 +1,2 @@
 /** Kept in step with package.json by test/browser.test.js; a browser bundle can't read package.json. */
-export const BROWSER_SDK_VERSION = "0.4.0";
+export const BROWSER_SDK_VERSION = "0.5.0";