@oxy.so/core 1.0.1 → 1.1.2

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/cache.js

@@ -85,6 +85,8 @@ class TTLCache {
         const effectiveTTL = ttl === undefined ? this.defaultTTL : ttl;
         const expiresAt = now + effectiveTTL;
         this.cache.set(key, { data, timestamp: now, expiresAt });
+        if (!cleanupInterval && activeCaches.has(this))
+            updateCleanupInterval();
     }
     /**
      * Delete a specific cache entry
@@ -92,7 +94,10 @@ class TTLCache {
      * @returns true if entry was deleted, false if not found
      */
     delete(key) {
-        return this.cache.delete(key);
+        const deleted = this.cache.delete(key);
+        if (activeCaches.has(this))
+            updateCleanupInterval();
+        return deleted;
     }
     /**
      * Clear all cache entries
@@ -101,6 +106,8 @@ class TTLCache {
         this.cache.clear();
         this.hits = 0;
         this.misses = 0;
+        if (activeCaches.has(this))
+            updateCleanupInterval();
     }
     /**
      * Check if a key exists and is not expired
@@ -199,28 +206,30 @@ const activeCaches = new Set();
  */
 function registerCacheForCleanup(cache) {
     activeCaches.add(cache);
-    // Start cleanup interval if not already running
-    if (!cleanupInterval) {
-        cleanupInterval = setInterval(() => {
-            for (const cache of activeCaches) {
-                cache.cleanup();
-            }
-        }, 60000); // Every minute
-        // Never block process/worker exit on a housekeeping timer.
-        cleanupInterval.unref?.();
+    updateCleanupInterval();
+}
+/** Empty registered caches need no timer; importing a client must stay inert. */
+function updateCleanupInterval() {
+    const hasEntries = [...activeCaches].some(cache => cache.size() > 0);
+    if (!hasEntries) {
+        if (cleanupInterval)
+            clearInterval(cleanupInterval);
+        cleanupInterval = null;
+        return;
     }
+    if (cleanupInterval)
+        return;
+    cleanupInterval = setInterval(() => {
+        for (const cache of activeCaches)
+            cache.cleanup();
+        updateCleanupInterval();
+    }, 60000);
+    cleanupInterval.unref?.();
 }
-/**
- * Unregister a cache from automatic cleanup
- * @param cache Cache instance to unregister
- */
+/** Unregister a cache without changing its entries or TTL behavior. */
 function unregisterCacheFromCleanup(cache) {
     activeCaches.delete(cache);
-    // Stop cleanup interval if no caches are registered
-    if (activeCaches.size === 0 && cleanupInterval) {
-        clearInterval(cleanupInterval);
-        cleanupInterval = null;
-    }
+    updateCleanupInterval();
 }
 /**
  * Stop all cleanup intervals (useful for testing)

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