polartrace 2.0.0

package/dist/metrics/host-metrics-monitor.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostMetricsMonitor = void 0;
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const perf_hooks_1 = require("perf_hooks");
+const NS_PER_MS = 1000000;
+const safePercentile = (histogram, percentile) => {
+    try {
+        return histogram.percentile(percentile) / NS_PER_MS;
+    }
+    catch {
+        return 0;
+    }
+};
+const readCgroupFile = (path) => {
+    try {
+        return fs.readFileSync(path, "utf-8").trim();
+    }
+    catch {
+        return null;
+    }
+};
+const readContainerMetrics = () => {
+    if (process.platform !== "linux")
+        return undefined;
+    const memMax = readCgroupFile("/sys/fs/cgroup/memory.max");
+    const memCurrent = readCgroupFile("/sys/fs/cgroup/memory.current");
+    const cpuMax = readCgroupFile("/sys/fs/cgroup/cpu.max");
+    if (memMax === null && memCurrent === null && cpuMax === null) {
+        return undefined;
+    }
+    const memoryLimitBytes = memMax === null || memMax === "max" ? null : Number.parseInt(memMax, 10);
+    const memoryUsageBytes = memCurrent === null ? null : Number.parseInt(memCurrent, 10);
+    let cpuLimitCores = null;
+    if (cpuMax) {
+        const [quotaStr, periodStr] = cpuMax.split(/\s+/);
+        if (quotaStr && quotaStr !== "max" && periodStr) {
+            const quota = Number.parseInt(quotaStr, 10);
+            const period = Number.parseInt(periodStr, 10);
+            if (!Number.isNaN(quota) && !Number.isNaN(period) && period > 0) {
+                cpuLimitCores = quota / period;
+            }
+        }
+    }
+    return {
+        memoryLimitBytes: memoryLimitBytes !== null && Number.isFinite(memoryLimitBytes)
+            ? memoryLimitBytes
+            : null,
+        memoryUsageBytes: memoryUsageBytes !== null && Number.isFinite(memoryUsageBytes)
+            ? memoryUsageBytes
+            : null,
+        cpuLimitCores,
+    };
+};
+class HostMetricsMonitor {
+    constructor(config) {
+        this.prevCpu = { user: 0, system: 0 };
+        this.prevWallMs = 0;
+        this.initialized = false;
+        this.config = {
+            sampleIntervalMs: 10000,
+            eventLoopResolutionMs: 20,
+            ...config,
+        };
+    }
+    initialize() {
+        if (this.initialized)
+            return;
+        try {
+            this.histogram = (0, perf_hooks_1.monitorEventLoopDelay)({
+                resolution: this.config.eventLoopResolutionMs,
+            });
+            this.histogram.enable();
+            this.prevCpu = process.cpuUsage();
+            this.prevWallMs = Date.now();
+            this.timer = setInterval(() => {
+                try {
+                    this.sample();
+                }
+                catch (err) {
+                    this.config.onError?.(err instanceof Error ? err : new Error(String(err)));
+                }
+            }, this.config.sampleIntervalMs);
+            this.timer.unref?.();
+            this.initialized = true;
+        }
+        catch (err) {
+            this.config.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    destroy() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+        if (this.histogram) {
+            this.histogram.disable();
+            this.histogram = undefined;
+        }
+        this.initialized = false;
+    }
+    sample() {
+        const nowMs = Date.now();
+        const cpu = process.cpuUsage();
+        const wallDeltaMs = Math.max(1, nowMs - this.prevWallMs);
+        const userDeltaMicros = cpu.user - this.prevCpu.user;
+        const systemDeltaMicros = cpu.system - this.prevCpu.system;
+        const cpuPercent = ((userDeltaMicros + systemDeltaMicros) / (wallDeltaMs * 1000)) * 100;
+        this.prevCpu = cpu;
+        this.prevWallMs = nowMs;
+        const mem = process.memoryUsage();
+        const histogram = this.histogram;
+        const eventLoop = histogram
+            ? {
+                meanMs: histogram.mean / NS_PER_MS,
+                p50Ms: safePercentile(histogram, 50),
+                p95Ms: safePercentile(histogram, 95),
+                p99Ms: safePercentile(histogram, 99),
+                maxMs: histogram.max / NS_PER_MS,
+            }
+            : { meanMs: 0, p50Ms: 0, p95Ms: 0, p99Ms: 0, maxMs: 0 };
+        histogram?.reset();
+        const loadAvg = os.loadavg();
+        const sample = {
+            timestamp: nowMs,
+            process: {
+                pid: process.pid,
+                cpuPercent: Number.isFinite(cpuPercent) ? cpuPercent : 0,
+                cpuUserMicros: cpu.user,
+                cpuSystemMicros: cpu.system,
+                rssBytes: mem.rss,
+                heapUsedBytes: mem.heapUsed,
+                heapTotalBytes: mem.heapTotal,
+                externalBytes: mem.external,
+                arrayBuffersBytes: mem.arrayBuffers ?? 0,
+                uptimeSeconds: process.uptime(),
+            },
+            eventLoop,
+            host: {
+                hostname: os.hostname(),
+                platform: process.platform,
+                cpuCount: os.cpus().length,
+                loadAvg1: loadAvg[0] ?? 0,
+                loadAvg5: loadAvg[1] ?? 0,
+                loadAvg15: loadAvg[2] ?? 0,
+                freeMemBytes: os.freemem(),
+                totalMemBytes: os.totalmem(),
+                uptimeSeconds: os.uptime(),
+                container: readContainerMetrics(),
+            },
+        };
+        this.config.onSample(sample);
+    }
+}
+exports.HostMetricsMonitor = HostMetricsMonitor;

package/dist/module-hook.d.ts

@@ -0,0 +1,3 @@
+type ModuleHandler = (exports: any) => any | void;
+export declare function onModuleLoad(packageName: string, handler: ModuleHandler): void;
+export {};

package/dist/module-hook.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onModuleLoad = onModuleLoad;
+const module_1 = __importDefault(require("module"));
+const path_1 = __importDefault(require("path"));
+const handlers = new Map();
+const entryCache = new Map();
+let installed = false;
+function packageEntryFor(request) {
+    if (!path_1.default.isAbsolute(request)) {
+        return request.startsWith(".") ? undefined : request;
+    }
+    if (entryCache.has(request))
+        return entryCache.get(request);
+    let result;
+    const marker = `${path_1.default.sep}node_modules${path_1.default.sep}`;
+    const idx = request.lastIndexOf(marker);
+    if (idx !== -1) {
+        const segments = request.slice(idx + marker.length).split(path_1.default.sep);
+        const name = segments[0]?.startsWith("@")
+            ? `${segments[0]}/${segments[1]}`
+            : segments[0];
+        if (name && handlers.has(name)) {
+            try {
+                const root = request.slice(0, idx + marker.length) + name;
+                if (require.resolve(root) === request)
+                    result = name;
+            }
+            catch {
+            }
+        }
+    }
+    entryCache.set(request, result);
+    return result;
+}
+function onModuleLoad(packageName, handler) {
+    const existing = handlers.get(packageName);
+    if (existing) {
+        existing.push(handler);
+    }
+    else {
+        handlers.set(packageName, [handler]);
+    }
+    entryCache.clear();
+    install();
+}
+function install() {
+    if (installed)
+        return;
+    installed = true;
+    const ModuleAny = module_1.default;
+    const originalLoad = ModuleAny._load;
+    ModuleAny._load = function (request) {
+        const exports = originalLoad.apply(this, arguments);
+        let name;
+        try {
+            name = packageEntryFor(request);
+        }
+        catch {
+            return exports;
+        }
+        if (!name)
+            return exports;
+        const list = handlers.get(name);
+        if (!list)
+            return exports;
+        let current = exports;
+        for (const handler of list) {
+            try {
+                const replacement = handler(current);
+                if (replacement !== undefined)
+                    current = replacement;
+            }
+            catch {
+            }
+        }
+        return current;
+    };
+}

package/dist/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/register.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts_loader_1 = require("./ts-loader");
+(0, ts_loader_1.registerTypeScriptLoaderIfNeeded)();
+const instrumentation_manager_1 = require("./instrumentations/instrumentation-manager");
+const mongo_instrumentation_1 = require("./instrumentations/mongo.instrumentation");
+const redis_instrumentation_1 = require("./instrumentations/redis.instrumentation");
+const postgres_instrumentation_1 = require("./instrumentations/postgres.instrumentation");
+const manager = instrumentation_manager_1.InstrumentationManager.getInstance();
+manager.register(new mongo_instrumentation_1.MongoInstrumentation(() => { }));
+manager.register(new redis_instrumentation_1.RedisInstrumentation(() => { }));
+manager.register(new postgres_instrumentation_1.PostgresInstrumentation(() => { }));
+manager.enableAll();
+globalThis.__POLARTRACE_MONGO_INSTRUMENTATION_ENABLED__ = true;
+globalThis.__POLARTRACE_REDIS_INSTRUMENTATION_ENABLED__ = true;
+globalThis.__POLARTRACE_POSTGRES_INSTRUMENTATION_ENABLED__ = true;

package/dist/trace/index.d.ts

@@ -0,0 +1 @@
+export { TraceMonitor, TraceSpan, TraceMonitorConfig } from './trace-monitor';

package/dist/trace/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceMonitor = void 0;
+var trace_monitor_1 = require("./trace-monitor");
+Object.defineProperty(exports, "TraceMonitor", { enumerable: true, get: function () { return trace_monitor_1.TraceMonitor; } });

package/dist/trace/trace-monitor.d.ts

@@ -0,0 +1,42 @@
+export interface TraceSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    status: {
+        code: string;
+        message?: string;
+    };
+    attributes: Record<string, any>;
+    events?: Array<{
+        name: string;
+        timestamp: number;
+        attributes?: Record<string, any>;
+    }>;
+    links?: Array<{
+        traceId: string;
+        spanId: string;
+    }>;
+    resource?: Record<string, any>;
+}
+export interface TraceMonitorConfig {
+    serviceName: string;
+    serviceVersion?: string;
+    onSpan: (span: TraceSpan) => void;
+    excludeAgentSpans?: boolean;
+    agentEndpoints?: string[];
+    sharedSpanIdMap?: Map<string, string>;
+}
+export declare class TraceMonitor {
+    private config;
+    private sdk?;
+    private isInitialized;
+    constructor(config: TraceMonitorConfig);
+    get initialized(): boolean;
+    initialize(): Promise<void>;
+    destroy(): void;
+}