@oxy.so/core 1.0.1 → 1.1.1

package/dist/cjs/server/trafficNodeHttp.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withoutNodeHttpObservation = withoutNodeHttpObservation;
+exports.observeNodeHttp = observeNodeHttp;
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_async_hooks_1 = require("node:async_hooks");
+const node_module_1 = require("node:module");
+const collector_1 = require("@oxy.so/telemetry/collector");
+const suppressed = new node_async_hooks_1.AsyncLocalStorage();
+function withoutNodeHttpObservation(callback) { return suppressed.run(true, callback); }
+/** Node and Bun share the HTTP facade; Bun does not emit Node's HTTP diagnostic channels. */
+function observeNodeHttp(collector, service, region, resolveEndpoint) {
+    const seen = new WeakSet();
+    const restoreRequests = new Set();
+    const observe = (request) => {
+        if (seen.has(request) || suppressed.getStore())
+            return request;
+        seen.add(request);
+        const host = request.getHeader('host') ?? request.host;
+        if (typeof host !== 'string')
+            return request;
+        const url = new URL(request.path || '/', `${request.protocol || 'http:'}//${host}`);
+        if (/^\/(?:internal\/activity|auth\/service-token|platform-infrastructure)(?:\/|$)/.test(url.pathname))
+            return request;
+        const peer = resolveEndpoint(url);
+        if (peer && !request.headersSent)
+            request.setHeader('X-Oxy-Source-Region', region);
+        const flow = { service, region, activityType: (0, collector_1.trafficType)(url.pathname), scope: peer ? 'internal' : 'external', direction: 'outbound', sourceRegion: region, sourceService: service, targetService: peer?.service };
+        const emit = request.emit;
+        let recorded = false;
+        const restore = () => { if (request.emit === observedEmit)
+            request.emit = emit; restoreRequests.delete(restore); };
+        // Intercept notifications without adding an 'error' listener: observation
+        // must not turn an unhandled application error into a swallowed error.
+        const observedEmit = function (event, ...args) {
+            try {
+                if (!recorded && event === 'response') {
+                    recorded = true;
+                    const response = args[0];
+                    const targetRegion = peer ? (0, collector_1.normalizeInfrastructureRegion)(response.headers['x-oxy-region']) : undefined;
+                    collector.record({ ...flow, targetRegion });
+                    collector.record({ ...flow, direction: 'inbound', sourceRegion: targetRegion, targetRegion: region, sourceService: peer?.service, targetService: service });
+                }
+                else if (!recorded && (event === 'error' || event === 'close')) {
+                    recorded = true;
+                    collector.record(flow);
+                }
+            }
+            catch { /* A metrics failure cannot change a request's behavior. */ }
+            if (event === 'close')
+                restore();
+            return emit.call(this, event, ...args);
+        };
+        request.emit = observedEmit;
+        restoreRequests.add(restore);
+        return request;
+    };
+    const safelyObserve = (request) => {
+        try {
+            return observe(request);
+        }
+        catch {
+            return request;
+        }
+    };
+    const patches = [node_http_1.default, node_https_1.default].map(module => {
+        const request = module.request;
+        const get = module.get;
+        const wrappedRequest = function (...args) { return safelyObserve(request.apply(module, args)); };
+        const wrappedGet = function (...args) { return safelyObserve(get.apply(module, args)); };
+        module.request = wrappedRequest;
+        module.get = wrappedGet;
+        return () => {
+            if (module.request === wrappedRequest)
+                module.request = request;
+            if (module.get === wrappedGet)
+                module.get = get;
+        };
+    });
+    (0, node_module_1.syncBuiltinESMExports)();
+    return () => { patches.forEach(restore => restore()); restoreRequests.forEach(restore => restore()); (0, node_module_1.syncBuiltinESMExports)(); };
+}

package/dist/cjs/utils/textNormalization.js

@@ -87,7 +87,7 @@ const LEADING_HORIZONTAL_WHITESPACE = /\n +/g;
 /** Three or more line breaks: more than one blank line between paragraphs. */
 const EXCESS_BLANK_LINES = /\n{3,}/g;
 /**
- * Normalize a SINGLE-LINE text value: page/link-preview titles, `siteName`,
+ * Normalize a SINGLE-LINE text value such as a page title or `siteName`,
  * display names, image alt text, handles, profile field labels.
  *
  * A line break in such a value is never meaningful — it is an artifact of the