polartrace 2.0.0

package/dist/instrumentations/instrumentation-manager.d.ts

@@ -0,0 +1,12 @@
+import { Instrumentation } from "./instrumentation";
+declare class InstrumentationManager {
+    private static instance;
+    private instrumentations;
+    static getInstance(): InstrumentationManager;
+    register(inst: Instrumentation): void;
+    updateMongoCallback(callback: (span: any) => void): boolean;
+    updateRedisCallback(callback: (span: any) => void): boolean;
+    updatePostgresCallback(callback: (span: any) => void): boolean;
+    enableAll(): void;
+}
+export { InstrumentationManager };

package/dist/instrumentations/instrumentation-manager.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstrumentationManager = void 0;
+const mongo_instrumentation_1 = require("./mongo.instrumentation");
+const redis_instrumentation_1 = require("./redis.instrumentation");
+const postgres_instrumentation_1 = require("./postgres.instrumentation");
+class InstrumentationManager {
+    constructor() {
+        this.instrumentations = [];
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new InstrumentationManager();
+        }
+        return this.instance;
+    }
+    register(inst) {
+        this.instrumentations.push(inst);
+    }
+    updateMongoCallback(callback) {
+        const mongoInst = this.instrumentations.find((inst) => inst instanceof mongo_instrumentation_1.MongoInstrumentation);
+        if (mongoInst) {
+            mongoInst.setOnSpan(callback);
+            return true;
+        }
+        return false;
+    }
+    updateRedisCallback(callback) {
+        const redisInst = this.instrumentations.find((inst) => inst instanceof redis_instrumentation_1.RedisInstrumentation);
+        if (redisInst) {
+            redisInst.setOnSpan(callback);
+            return true;
+        }
+        return false;
+    }
+    updatePostgresCallback(callback) {
+        const pgInst = this.instrumentations.find((inst) => inst instanceof postgres_instrumentation_1.PostgresInstrumentation);
+        if (pgInst) {
+            pgInst.setOnSpan(callback);
+            return true;
+        }
+        return false;
+    }
+    enableAll() {
+        for (const inst of this.instrumentations) {
+            inst.enable();
+        }
+    }
+}
+exports.InstrumentationManager = InstrumentationManager;

package/dist/instrumentations/instrumentation.d.ts

@@ -0,0 +1,4 @@
+export interface Instrumentation {
+    name: string;
+    enable(): void;
+}

package/dist/instrumentations/instrumentation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/instrumentations/mongo.instrumentation.d.ts

@@ -0,0 +1,32 @@
+import { Instrumentation } from "./instrumentation";
+export interface MongoSdkSpan {
+    name: string;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    attributes: {
+        db?: string;
+        command?: string;
+        collection?: string;
+        [key: string]: any;
+    };
+    error?: any;
+    parentSpanId?: string;
+    traceId?: string;
+}
+export declare class MongoInstrumentation implements Instrumentation {
+    private readonly mongoose?;
+    name: string;
+    private trackedClients;
+    private spans;
+    private requireHookInstalled;
+    private onSpanCallback;
+    constructor(onSpan: (span: MongoSdkSpan) => void, mongoose?: any | undefined);
+    setOnSpan(callback: (span: MongoSdkSpan) => void): void;
+    enable(): void;
+    private patchExistingDriver;
+    private installRequireHook;
+    private patchMongoDriver;
+    private attach;
+    private end;
+}

package/dist/instrumentations/mongo.instrumentation.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoInstrumentation = void 0;
+const module_hook_1 = require("../module-hook");
+const api_1 = require("@opentelemetry/api");
+class MongoInstrumentation {
+    constructor(onSpan, mongoose) {
+        this.mongoose = mongoose;
+        this.name = "mongodb";
+        this.trackedClients = new WeakSet();
+        this.spans = new Map();
+        this.requireHookInstalled = false;
+        this.onSpanCallback = onSpan;
+    }
+    setOnSpan(callback) {
+        this.onSpanCallback = callback;
+    }
+    enable() {
+        this.patchExistingDriver();
+        this.installRequireHook();
+        if (this.mongoose?.connection) {
+            this.mongoose.connection.once("open", () => {
+                const client = this.mongoose.connection.client;
+                if (client) {
+                    this.attach(client);
+                }
+            });
+        }
+    }
+    patchExistingDriver() {
+        try {
+            if (this.mongoose?.mongo) {
+                this.patchMongoDriver(this.mongoose.mongo);
+            }
+            const cached = require.cache;
+            for (const key of Object.keys(cached)) {
+                if (key.includes("mongodb")) {
+                    const exports = cached[key]?.exports;
+                    if (exports?.MongoClient) {
+                        this.patchMongoDriver(exports);
+                    }
+                }
+            }
+        }
+        catch {
+        }
+    }
+    installRequireHook() {
+        if (this.requireHookInstalled)
+            return;
+        this.requireHookInstalled = true;
+        const self = this;
+        (0, module_hook_1.onModuleLoad)("mongodb", (exports) => self.patchMongoDriver(exports));
+    }
+    patchMongoDriver(mongodb) {
+        const MongoClient = mongodb?.MongoClient;
+        if (!MongoClient)
+            return;
+        if (MongoClient.__polartrace_patched)
+            return;
+        MongoClient.__polartrace_patched = true;
+        const self = this;
+        const originalConnect = MongoClient.prototype.connect;
+        MongoClient.prototype.connect = async function (...args) {
+            try {
+                const opts = this.options || this.s?.options;
+                if (opts)
+                    opts.monitorCommands = true;
+            }
+            catch {
+            }
+            const result = await originalConnect.apply(this, args);
+            self.attach(this);
+            return result;
+        };
+    }
+    attach(client) {
+        if (this.trackedClients.has(client))
+            return;
+        this.trackedClients.add(client);
+        const emitter = typeof client?.on === "function"
+            ? client
+            : client.topology || client?.s?.topology;
+        if (!emitter?.on)
+            return;
+        emitter.on("commandStarted", (ev) => {
+            const activeSpan = api_1.trace.getActiveSpan();
+            let parentSpanId;
+            let traceId;
+            if (activeSpan) {
+                const spanContext = activeSpan.spanContext();
+                traceId = spanContext.traceId;
+                parentSpanId = spanContext.spanId;
+            }
+            this.spans.set(ev.requestId, {
+                name: `mongodb.${ev.commandName}`,
+                startTime: Date.now(),
+                attributes: {
+                    db: ev.databaseName,
+                    command: ev.commandName,
+                    collection: extractCollection(ev.command),
+                },
+                parentSpanId,
+                traceId,
+            });
+        });
+        emitter.on("commandSucceeded", (ev) => {
+            this.end(ev.requestId);
+        });
+        emitter.on("commandFailed", (ev) => {
+            this.end(ev.requestId, ev.failure);
+        });
+    }
+    end(id, error) {
+        const span = this.spans.get(id);
+        if (!span)
+            return;
+        const end = Date.now();
+        span.endTime = end;
+        span.durationMs = end - span.startTime;
+        if (error)
+            span.error = error;
+        this.onSpanCallback(span);
+        this.spans.delete(id);
+    }
+}
+exports.MongoInstrumentation = MongoInstrumentation;
+function extractCollection(cmd) {
+    const key = Object.keys(cmd || {})[0];
+    return typeof cmd?.[key] === "string" ? cmd[key] : undefined;
+}

package/dist/instrumentations/postgres.instrumentation.d.ts

@@ -0,0 +1,29 @@
+import { Instrumentation } from "./instrumentation";
+export interface PostgresSdkSpan {
+    name: string;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    attributes: {
+        operation?: string;
+        table?: string;
+        statement?: string;
+        [key: string]: any;
+    };
+    error?: any;
+    parentSpanId?: string;
+    traceId?: string;
+}
+export declare class PostgresInstrumentation implements Instrumentation {
+    name: string;
+    private requireHookInstalled;
+    private onSpanCallback;
+    constructor(onSpan: (span: PostgresSdkSpan) => void);
+    setOnSpan(callback: (span: PostgresSdkSpan) => void): void;
+    enable(): void;
+    private patchExistingDrivers;
+    private installRequireHook;
+    private patchPg;
+    private beginSpan;
+    private end;
+}

package/dist/instrumentations/postgres.instrumentation.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresInstrumentation = void 0;
+const module_hook_1 = require("../module-hook");
+const api_1 = require("@opentelemetry/api");
+const MAX_STATEMENT_LENGTH = 500;
+class PostgresInstrumentation {
+    constructor(onSpan) {
+        this.name = "postgres";
+        this.requireHookInstalled = false;
+        this.onSpanCallback = onSpan;
+    }
+    setOnSpan(callback) {
+        this.onSpanCallback = callback;
+    }
+    enable() {
+        this.patchExistingDrivers();
+        this.installRequireHook();
+    }
+    patchExistingDrivers() {
+        try {
+            const cached = require.cache;
+            for (const key of Object.keys(cached)) {
+                const exports = cached[key]?.exports;
+                if (!exports)
+                    continue;
+                if (key.includes("node_modules/pg/")) {
+                    this.patchPg(exports);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    installRequireHook() {
+        if (this.requireHookInstalled)
+            return;
+        this.requireHookInstalled = true;
+        const self = this;
+        (0, module_hook_1.onModuleLoad)("pg", (exports) => self.patchPg(exports));
+    }
+    patchPg(mod) {
+        const pg = mod?.default || mod;
+        const Client = pg?.Client;
+        if (!Client?.prototype?.query)
+            return;
+        if (Client.__polartrace_patched)
+            return;
+        Client.__polartrace_patched = true;
+        const self = this;
+        const originalQuery = Client.prototype.query;
+        Client.prototype.query = function (config, values, callback) {
+            const text = extractQueryText(config);
+            if (config && typeof config.submit === "function") {
+                return originalQuery.call(this, config, values, callback);
+            }
+            const span = self.beginSpan(text);
+            let cb = callback;
+            let vals = values;
+            if (typeof values === "function") {
+                cb = values;
+                vals = undefined;
+            }
+            if (typeof cb === "function") {
+                const wrappedCb = function (err, res) {
+                    self.end(span, err);
+                    return cb(err, res);
+                };
+                return originalQuery.call(this, config, vals, wrappedCb);
+            }
+            const result = originalQuery.call(this, config, vals);
+            if (result && typeof result.then === "function") {
+                result.then(() => self.end(span), (err) => self.end(span, err));
+            }
+            else {
+                self.end(span);
+            }
+            return result;
+        };
+    }
+    beginSpan(text) {
+        const activeSpan = api_1.trace.getActiveSpan();
+        let parentSpanId;
+        let traceId;
+        if (activeSpan) {
+            const spanContext = activeSpan.spanContext();
+            traceId = spanContext.traceId;
+            parentSpanId = spanContext.spanId;
+        }
+        const operation = extractOperation(text);
+        return {
+            name: `postgres.${operation ? operation.toLowerCase() : "query"}`,
+            startTime: Date.now(),
+            attributes: {
+                operation,
+                table: extractTable(text),
+                statement: truncateStatement(text),
+            },
+            parentSpanId,
+            traceId,
+        };
+    }
+    end(span, error) {
+        const end = Date.now();
+        span.endTime = end;
+        span.durationMs = end - span.startTime;
+        if (error)
+            span.error = error;
+        this.onSpanCallback(span);
+    }
+}
+exports.PostgresInstrumentation = PostgresInstrumentation;
+function extractQueryText(config) {
+    if (typeof config === "string")
+        return config;
+    if (config && typeof config.text === "string")
+        return config.text;
+    return undefined;
+}
+function redactStatementLiterals(text) {
+    return text.replace(/'(?:[^']|'')*'/g, "'?'");
+}
+function extractOperation(text) {
+    if (!text)
+        return undefined;
+    const match = text.match(/^\s*([a-zA-Z]+)/);
+    return match ? match[1].toUpperCase() : undefined;
+}
+function extractTable(text) {
+    if (!text)
+        return undefined;
+    const match = text.match(/\b(?:from|into|update|join)\s+"?([a-zA-Z0-9_.]+)"?/i);
+    return match ? match[1] : undefined;
+}
+function truncateStatement(text) {
+    text = text === undefined ? text : redactStatementLiterals(text);
+    if (!text)
+        return undefined;
+    return text.length > MAX_STATEMENT_LENGTH
+        ? text.slice(0, MAX_STATEMENT_LENGTH)
+        : text;
+}

package/dist/instrumentations/redis.instrumentation.d.ts

@@ -0,0 +1,31 @@
+import { Instrumentation } from "./instrumentation";
+export interface RedisSdkSpan {
+    name: string;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    attributes: {
+        library?: string;
+        command?: string;
+        key?: string;
+        [key: string]: any;
+    };
+    error?: any;
+    parentSpanId?: string;
+    traceId?: string;
+}
+export declare class RedisInstrumentation implements Instrumentation {
+    name: string;
+    private requireHookInstalled;
+    private onSpanCallback;
+    constructor(onSpan: (span: RedisSdkSpan) => void);
+    setOnSpan(callback: (span: RedisSdkSpan) => void): void;
+    enable(): void;
+    private patchExistingDrivers;
+    private installRequireHook;
+    private patchIoredis;
+    private patchNodeRedis;
+    private patchNodeRedisClient;
+    private beginSpan;
+    private end;
+}

package/dist/instrumentations/redis.instrumentation.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisInstrumentation = void 0;
+const module_hook_1 = require("../module-hook");
+const api_1 = require("@opentelemetry/api");
+class RedisInstrumentation {
+    constructor(onSpan) {
+        this.name = "redis";
+        this.requireHookInstalled = false;
+        this.onSpanCallback = onSpan;
+    }
+    setOnSpan(callback) {
+        this.onSpanCallback = callback;
+    }
+    enable() {
+        this.patchExistingDrivers();
+        this.installRequireHook();
+    }
+    patchExistingDrivers() {
+        try {
+            const cached = require.cache;
+            for (const key of Object.keys(cached)) {
+                const exports = cached[key]?.exports;
+                if (!exports)
+                    continue;
+                if (key.includes("node_modules/ioredis")) {
+                    this.patchIoredis(exports);
+                }
+                else if (key.includes("node_modules/redis/") ||
+                    key.endsWith("node_modules/redis/dist/index.js")) {
+                    this.patchNodeRedis(exports);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    installRequireHook() {
+        if (this.requireHookInstalled)
+            return;
+        this.requireHookInstalled = true;
+        const self = this;
+        (0, module_hook_1.onModuleLoad)("ioredis", (exports) => self.patchIoredis(exports));
+        (0, module_hook_1.onModuleLoad)("redis", (exports) => self.patchNodeRedis(exports));
+    }
+    patchIoredis(mod) {
+        const Redis = mod?.default || mod;
+        if (!Redis?.prototype?.sendCommand)
+            return;
+        if (Redis.__polartrace_patched)
+            return;
+        Redis.__polartrace_patched = true;
+        const self = this;
+        const originalSendCommand = Redis.prototype.sendCommand;
+        Redis.prototype.sendCommand = function (command, stream) {
+            const span = self.beginSpan("ioredis", command?.name, command?.args);
+            const result = originalSendCommand.call(this, command, stream);
+            const promise = command?.promise;
+            if (promise && typeof promise.then === "function") {
+                promise.then(() => self.end(span), (err) => self.end(span, err));
+            }
+            else {
+                self.end(span);
+            }
+            return result;
+        };
+    }
+    patchNodeRedis(mod) {
+        if (!mod || typeof mod.createClient !== "function")
+            return;
+        if (mod.__polartrace_patched)
+            return;
+        mod.__polartrace_patched = true;
+        const self = this;
+        const originalCreateClient = mod.createClient;
+        mod.createClient = function (...args) {
+            const client = originalCreateClient.apply(this, args);
+            self.patchNodeRedisClient(client);
+            return client;
+        };
+        if (typeof mod.createCluster === "function") {
+            const originalCreateCluster = mod.createCluster;
+            mod.createCluster = function (...args) {
+                const cluster = originalCreateCluster.apply(this, args);
+                self.patchNodeRedisClient(cluster);
+                return cluster;
+            };
+        }
+    }
+    patchNodeRedisClient(client) {
+        if (!client)
+            return;
+        let proto = Object.getPrototypeOf(client);
+        while (proto && !Object.prototype.hasOwnProperty.call(proto, "sendCommand")) {
+            proto = Object.getPrototypeOf(proto);
+        }
+        if (!proto || proto.__polartrace_patched)
+            return;
+        proto.__polartrace_patched = true;
+        const self = this;
+        for (const name of Object.getOwnPropertyNames(proto)) {
+            let original;
+            try {
+                original = proto[name];
+            }
+            catch {
+                continue;
+            }
+            if (typeof original !== "function")
+                continue;
+            let isGeneratedCommand = false;
+            try {
+                isGeneratedCommand = /executor\.call\(/.test(Function.prototype.toString.call(original));
+            }
+            catch {
+                continue;
+            }
+            if (!isGeneratedCommand)
+                continue;
+            proto[name] = function (...args) {
+                const span = self.beginSpan("redis", name.toLowerCase(), args);
+                let result;
+                try {
+                    result = original.apply(this, args);
+                }
+                catch (err) {
+                    self.end(span, err);
+                    throw err;
+                }
+                if (result && typeof result.then === "function") {
+                    return result.then((value) => {
+                        self.end(span);
+                        return value;
+                    }, (err) => {
+                        self.end(span, err);
+                        throw err;
+                    });
+                }
+                self.end(span);
+                return result;
+            };
+        }
+    }
+    beginSpan(library, command, args) {
+        const activeSpan = api_1.trace.getActiveSpan();
+        let parentSpanId;
+        let traceId;
+        if (activeSpan) {
+            const spanContext = activeSpan.spanContext();
+            traceId = spanContext.traceId;
+            parentSpanId = spanContext.spanId;
+        }
+        return {
+            name: `redis.${command || "unknown"}`,
+            startTime: Date.now(),
+            attributes: {
+                library,
+                command,
+                key: extractKey(args),
+            },
+            parentSpanId,
+            traceId,
+        };
+    }
+    end(span, error) {
+        const end = Date.now();
+        span.endTime = end;
+        span.durationMs = end - span.startTime;
+        if (error)
+            span.error = error;
+        this.onSpanCallback(span);
+    }
+}
+exports.RedisInstrumentation = RedisInstrumentation;
+function extractKey(args) {
+    if (!Array.isArray(args) || args.length === 0)
+        return undefined;
+    const first = args[0];
+    if (first === null || first === undefined)
+        return undefined;
+    const str = typeof first === "string" ? first : String(first);
+    return str.length > 128 ? str.slice(0, 128) : str;
+}

package/dist/metrics/host-metrics-monitor.d.ts

@@ -0,0 +1,57 @@
+export interface HostMetricSample {
+    timestamp: number;
+    process: {
+        pid: number;
+        cpuPercent: number;
+        cpuUserMicros: number;
+        cpuSystemMicros: number;
+        rssBytes: number;
+        heapUsedBytes: number;
+        heapTotalBytes: number;
+        externalBytes: number;
+        arrayBuffersBytes: number;
+        uptimeSeconds: number;
+    };
+    eventLoop: {
+        meanMs: number;
+        p50Ms: number;
+        p95Ms: number;
+        p99Ms: number;
+        maxMs: number;
+    };
+    host: {
+        hostname: string;
+        platform: string;
+        cpuCount: number;
+        loadAvg1: number;
+        loadAvg5: number;
+        loadAvg15: number;
+        freeMemBytes: number;
+        totalMemBytes: number;
+        uptimeSeconds: number;
+        container?: {
+            memoryLimitBytes: number | null;
+            memoryUsageBytes: number | null;
+            cpuLimitCores: number | null;
+        };
+    };
+}
+export interface HostMetricsMonitorConfig {
+    serviceName: string;
+    sampleIntervalMs?: number;
+    eventLoopResolutionMs?: number;
+    onSample: (sample: HostMetricSample) => void;
+    onError?: (err: Error) => void;
+}
+export declare class HostMetricsMonitor {
+    private readonly config;
+    private timer?;
+    private histogram?;
+    private prevCpu;
+    private prevWallMs;
+    initialized: boolean;
+    constructor(config: HostMetricsMonitorConfig);
+    initialize(): void;
+    destroy(): void;
+    private sample;
+}