@oxy.so/core 1.0.1 → 1.1.0

package/dist/esm/server/trafficNodeHttp.js

@@ -0,0 +1,79 @@
+import http from 'node:http';
+import https from 'node:https';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { syncBuiltinESMExports } from 'node:module';
+import { normalizeInfrastructureRegion, trafficType } from '@oxy.so/telemetry/collector';
+const suppressed = new AsyncLocalStorage();
+export function withoutNodeHttpObservation(callback) { return suppressed.run(true, callback); }
+/** Node and Bun share the HTTP facade; Bun does not emit Node's HTTP diagnostic channels. */
+export 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: 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 ? 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 = [http, https].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;
+        };
+    });
+    syncBuiltinESMExports();
+    return () => { patches.forEach(restore => restore()); restoreRequests.forEach(restore => restore()); syncBuiltinESMExports(); };
+}

package/dist/esm/utils/textNormalization.js

@@ -83,7 +83,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