@webtypen/webframez-core 0.3.14 → 0.3.15

package/dist/ConsoleApplication.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleApplication = void 0;
+/// <reference types="node" />
 const Config_1 = require("./Config");
 const ConsoleOutputHelper_1 = require("./Commands/ConsoleOutputHelper");
 const QueueWorkerCommand_1 = require("./Commands/QueueWorkerCommand");
@@ -22,6 +23,7 @@ const QueueStopCommand_1 = require("./Commands/QueueStopCommand");
 const QueueLogCommand_1 = require("./Commands/QueueLogCommand");
 const QueueWorkerAutorestartCommand_1 = require("./Commands/QueueWorkerAutorestartCommand");
 const info_1 = require("./info");
+const SigNozTelemetry_1 = require("./Telemetry/SigNozTelemetry");
 class ConsoleApplication {
     constructor() {
         this.systemCommands = [
@@ -43,6 +45,9 @@ class ConsoleApplication {
                 Config_1.Config.register(key, options.config[key]);
             }
         }
+        if (options && options.signoz) {
+            void SigNozTelemetry_1.SigNozTelemetry.init(options.signoz);
+        }
         if (options && options.datatables) {
             DatatableRegistry_1.DatatableRegistry.registerMany(options.datatables);
         }

package/dist/Telemetry/SigNozTelemetry.d.ts

@@ -0,0 +1,33 @@
+export interface SigNozOptions {
+    enabled?: boolean;
+    serviceName?: string;
+    endpoint?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    environment?: string;
+    resourceAttributes?: Record<string, unknown>;
+    samplingRatio?: number;
+    instrumentations?: any[];
+    autoInstrumentations?: boolean;
+    autoInstrumentationConfig?: Record<string, unknown>;
+    logInitialization?: boolean;
+}
+export declare class SigNozTelemetry {
+    private static sdk;
+    private static initPromise;
+    private static shutdownRegistered;
+    private static readonly missingDependencies;
+    private static readonly shutdownListener;
+    static init(options?: SigNozOptions): Promise<void>;
+    private static initialize;
+    static shutdown(): Promise<void>;
+    private static safeImport;
+    private static ensureEndpoint;
+    private static warnMissingDependency;
+    private static registerShutdownHooks;
+    private static getProcess;
+    private static getEnv;
+    private static getConsole;
+    private static logInfo;
+    private static logWarn;
+}

package/dist/Telemetry/SigNozTelemetry.js

@@ -0,0 +1,253 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SigNozTelemetry = void 0;
+const Config_1 = require("../Config");
+class SigNozTelemetry {
+    static init(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!options || options.enabled === false) {
+                return;
+            }
+            if (this.sdk) {
+                return;
+            }
+            if (this.initPromise) {
+                yield this.initPromise;
+                return;
+            }
+            const initialization = (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.initialize(options);
+                }
+                catch (error) {
+                    this.logWarn("[SigNoz] Initialization failed:", error);
+                }
+            }))();
+            this.initPromise = initialization;
+            try {
+                yield initialization;
+            }
+            finally {
+                this.initPromise = null;
+            }
+        });
+    }
+    static initialize(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sdkModule = yield this.safeImport("@opentelemetry/sdk-node");
+            const traceExporterModule = yield this.safeImport("@opentelemetry/exporter-trace-otlp-http");
+            const resourcesModule = yield this.safeImport("@opentelemetry/resources");
+            const semanticModule = yield this.safeImport("@opentelemetry/semantic-conventions");
+            if (!(sdkModule === null || sdkModule === void 0 ? void 0 : sdkModule.NodeSDK) || !(traceExporterModule === null || traceExporterModule === void 0 ? void 0 : traceExporterModule.OTLPTraceExporter) || !(resourcesModule === null || resourcesModule === void 0 ? void 0 : resourcesModule.Resource) || !(semanticModule === null || semanticModule === void 0 ? void 0 : semanticModule.SemanticResourceAttributes)) {
+                throw new Error("OpenTelemetry packages are missing. Install '@opentelemetry/sdk-node', '@opentelemetry/exporter-trace-otlp-http', '@opentelemetry/resources' and '@opentelemetry/semantic-conventions'.");
+            }
+            const serviceName = options.serviceName ||
+                Config_1.Config.get("application.serviceName") ||
+                Config_1.Config.get("application.name") ||
+                this.getEnv("SIGNOZ_SERVICE_NAME") ||
+                this.getEnv("OTEL_SERVICE_NAME") ||
+                "webframez-service";
+            const environment = options.environment ||
+                Config_1.Config.get("application.environment") ||
+                this.getEnv("SIGNOZ_ENVIRONMENT") ||
+                this.getEnv("NODE_ENV") ||
+                "development";
+            const traceEndpoint = this.ensureEndpoint(options.endpoint ||
+                this.getEnv("SIGNOZ_ENDPOINT") ||
+                this.getEnv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT") ||
+                this.getEnv("OTEL_EXPORTER_OTLP_ENDPOINT"), "http://localhost:4318", "/v1/traces");
+            const headers = Object.assign({}, (options.headers || {}));
+            const apiKey = options.apiKey || this.getEnv("SIGNOZ_API_KEY");
+            if (apiKey && !headers["signoz-access-token"]) {
+                headers["signoz-access-token"] = apiKey;
+            }
+            const { NodeSDK } = sdkModule;
+            const { OTLPTraceExporter } = traceExporterModule;
+            const { Resource } = resourcesModule;
+            const { SemanticResourceAttributes } = semanticModule;
+            const resourceAttributes = {
+                [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+                [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: environment,
+            };
+            if (options.resourceAttributes) {
+                Object.assign(resourceAttributes, options.resourceAttributes);
+            }
+            const resource = new Resource(resourceAttributes);
+            let instrumentations = options.instrumentations ? [...options.instrumentations] : [];
+            if (instrumentations.length === 0 && options.autoInstrumentations !== false) {
+                const autoModule = yield this.safeImport("@opentelemetry/auto-instrumentations-node");
+                if (autoModule === null || autoModule === void 0 ? void 0 : autoModule.getNodeAutoInstrumentations) {
+                    instrumentations = [autoModule.getNodeAutoInstrumentations(options.autoInstrumentationConfig || {})];
+                }
+                else {
+                    this.warnMissingDependency("@opentelemetry/auto-instrumentations-node");
+                }
+            }
+            let traceSampler;
+            if (typeof options.samplingRatio === "number") {
+                const samplerModule = yield this.safeImport("@opentelemetry/sdk-trace-base");
+                if ((samplerModule === null || samplerModule === void 0 ? void 0 : samplerModule.ParentBasedSampler) && (samplerModule === null || samplerModule === void 0 ? void 0 : samplerModule.TraceIdRatioBasedSampler)) {
+                    const ratio = Math.min(Math.max(options.samplingRatio, 0), 1);
+                    traceSampler = new samplerModule.ParentBasedSampler({
+                        root: new samplerModule.TraceIdRatioBasedSampler(ratio),
+                    });
+                }
+                else {
+                    this.warnMissingDependency("@opentelemetry/sdk-trace-base");
+                }
+            }
+            const traceExporter = new OTLPTraceExporter({
+                url: traceEndpoint,
+                headers,
+            });
+            const sdkOptions = {
+                resource,
+                traceExporter,
+            };
+            if (instrumentations && instrumentations.length > 0) {
+                sdkOptions.instrumentations = instrumentations;
+            }
+            if (traceSampler) {
+                sdkOptions.traceSampler = traceSampler;
+            }
+            this.sdk = new NodeSDK(sdkOptions);
+            yield this.sdk.start();
+            if (options.logInitialization !== false) {
+                this.logInfo(`[SigNoz] Telemetry enabled (service="${serviceName}", endpoint="${traceEndpoint}")`);
+            }
+            this.registerShutdownHooks();
+        });
+    }
+    static shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sdk) {
+                return;
+            }
+            const sdkToShutdown = this.sdk;
+            this.sdk = null;
+            try {
+                yield sdkToShutdown.shutdown();
+            }
+            catch (error) {
+                this.logWarn("[SigNoz] Shutdown failed:", error);
+            }
+        });
+    }
+    static safeImport(moduleName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const module = yield (_a = moduleName, Promise.resolve().then(() => __importStar(require(_a))));
+                return module;
+            }
+            catch (error) {
+                if (error && (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_MODULE_NOT_FOUND")) {
+                    return null;
+                }
+                throw error;
+            }
+        });
+    }
+    static ensureEndpoint(value, fallbackHost, defaultPath) {
+        const base = value && value.trim() !== "" ? value.trim() : fallbackHost;
+        if (base.includes("/v1/") || base.endsWith(defaultPath)) {
+            return base;
+        }
+        return `${base.replace(/\/$/, "")}${defaultPath}`;
+    }
+    static warnMissingDependency(name) {
+        if (this.missingDependencies.has(name)) {
+            return;
+        }
+        this.missingDependencies.add(name);
+        this.logWarn(`[SigNoz] Optional package "${name}" not found. Install it to enable the related feature.`);
+    }
+    static registerShutdownHooks() {
+        if (this.shutdownRegistered) {
+            return;
+        }
+        const nodeProcess = this.getProcess();
+        if (!nodeProcess) {
+            return;
+        }
+        nodeProcess.once("beforeExit", this.shutdownListener);
+        nodeProcess.once("exit", this.shutdownListener);
+        this.shutdownRegistered = true;
+    }
+    static getProcess() {
+        if (typeof globalThis === "undefined") {
+            return undefined;
+        }
+        const candidate = globalThis.process;
+        if (candidate && typeof candidate.once === "function") {
+            return candidate;
+        }
+        return undefined;
+    }
+    static getEnv(key) {
+        const nodeProcess = this.getProcess();
+        if (!nodeProcess || !nodeProcess.env) {
+            return undefined;
+        }
+        const value = nodeProcess.env[key];
+        return typeof value === "string" ? value : undefined;
+    }
+    static getConsole() {
+        if (typeof globalThis === "undefined") {
+            return undefined;
+        }
+        return globalThis.console;
+    }
+    static logInfo(...args) {
+        const target = this.getConsole();
+        if (target && typeof target.info === "function") {
+            target.info(...args);
+        }
+    }
+    static logWarn(...args) {
+        const target = this.getConsole();
+        if (target && typeof target.warn === "function") {
+            target.warn(...args);
+        }
+    }
+}
+exports.SigNozTelemetry = SigNozTelemetry;
+SigNozTelemetry.sdk = null;
+SigNozTelemetry.initPromise = null;
+SigNozTelemetry.shutdownRegistered = false;
+SigNozTelemetry.missingDependencies = new Set();
+SigNozTelemetry.shutdownListener = () => {
+    void SigNozTelemetry.shutdown();
+};

package/dist/WebApplication.js

@@ -4,12 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebApplication = void 0;
+/// <reference types="node" />
 const http_1 = __importDefault(require("http"));
 const Config_1 = require("./Config");
 const Router_1 = require("./Router/Router");
 const QueueJobsRegisty_1 = require("./Queue/QueueJobsRegisty");
 const DatatableRegistry_1 = require("./Datatable/DatatableRegistry");
 const ModulesLoader_1 = require("./Modules/ModulesLoader");
+const SigNozTelemetry_1 = require("./Telemetry/SigNozTelemetry");
 class WebApplication {
     constructor() {
         this.modulesLoader = null;
@@ -23,6 +25,9 @@ class WebApplication {
                 Config_1.Config.register(key, options.config[key]);
             }
         }
+        if (options && options.signoz) {
+            void SigNozTelemetry_1.SigNozTelemetry.init(options.signoz);
+        }
         this.modulesLoader = new ModulesLoader_1.ModulesLoader();
         this.modulesLoader.load(options && options.modules ? options.modules : []);
         if (options && options.kernel) {
@@ -46,10 +51,16 @@ class WebApplication {
         this.server = http_1.default.createServer((req, res) => {
             Router_1.Router.handleRequest(req, res);
         });
+        this.server.on("close", () => {
+            void SigNozTelemetry_1.SigNozTelemetry.shutdown();
+        });
         this.server.listen(port, () => {
-            console.log("Server started and listening on port " +
-                port +
-                (options && options.basename ? " (Basename: " + options && options.basename + ")" : ""));
+            const runtimeConsole = typeof globalThis !== "undefined" ? globalThis.console : undefined;
+            if (runtimeConsole && typeof runtimeConsole.log === "function") {
+                runtimeConsole.log("Server started and listening on port " +
+                    port +
+                    (options && options.basename ? " (Basename: " + options && options.basename + ")" : ""));
+            }
             if (options && options.onBoot) {
                 options.onBoot(port);
             }

package/dist/index.d.ts

@@ -31,4 +31,5 @@ export * from "./Queue/QueueJob";
 export * from "./Queue/QueueJobsRegisty";
 export * from "./Commands/ConsoleOutputHelper";
 export * from "./Modules/ModuleProvider";
+export * from "./Telemetry/SigNozTelemetry";
 export * from "./info";

package/dist/index.js

@@ -47,4 +47,5 @@ __exportStar(require("./Queue/QueueJob"), exports);
 __exportStar(require("./Queue/QueueJobsRegisty"), exports);
 __exportStar(require("./Commands/ConsoleOutputHelper"), exports);
 __exportStar(require("./Modules/ModuleProvider"), exports);
+__exportStar(require("./Telemetry/SigNozTelemetry"), exports);
 __exportStar(require("./info"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.3.14",
+    "version": "0.3.15",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",

package/src/ConsoleApplication.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { Config } from "./Config";
 import { ConsoleOutputHelper } from "./Commands/ConsoleOutputHelper";
 import { QueueWorkerCommand } from "./Commands/QueueWorkerCommand";
@@ -10,6 +11,7 @@ import { QueueStopCommand } from "./Commands/QueueStopCommand";
 import { QueueLogCommand } from "./Commands/QueueLogCommand";
 import { QueueWorkerAutorestartCommand } from "./Commands/QueueWorkerAutorestartCommand";
 import { WebframezInfo } from "./info";
+import { SigNozTelemetry } from "./Telemetry/SigNozTelemetry";
 
 export class ConsoleApplication {
     systemCommands: any = [
@@ -32,6 +34,10 @@ export class ConsoleApplication {
             }
         }
 
+        if (options && options.signoz) {
+            void SigNozTelemetry.init(options.signoz);
+        }
+
         if (options && options.datatables) {
             DatatableRegistry.registerMany(options.datatables);
         }

package/src/Telemetry/SigNozTelemetry.ts

@@ -0,0 +1,260 @@
+import { Config } from "../Config";
+
+export interface SigNozOptions {
+    enabled?: boolean;
+    serviceName?: string;
+    endpoint?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    environment?: string;
+    resourceAttributes?: Record<string, unknown>;
+    samplingRatio?: number;
+    instrumentations?: any[];
+    autoInstrumentations?: boolean;
+    autoInstrumentationConfig?: Record<string, unknown>;
+    logInitialization?: boolean;
+}
+
+export class SigNozTelemetry {
+    private static sdk: any = null;
+    private static initPromise: Promise<void> | null = null;
+    private static shutdownRegistered = false;
+    private static readonly missingDependencies = new Set<string>();
+    private static readonly shutdownListener = () => {
+        void SigNozTelemetry.shutdown();
+    };
+
+    static async init(options?: SigNozOptions): Promise<void> {
+        if (!options || options.enabled === false) {
+            return;
+        }
+        if (this.sdk) {
+            return;
+        }
+        if (this.initPromise) {
+            await this.initPromise;
+            return;
+        }
+
+        const initialization = (async () => {
+            try {
+                await this.initialize(options);
+            } catch (error) {
+                this.logWarn("[SigNoz] Initialization failed:", error);
+            }
+        })();
+
+        this.initPromise = initialization;
+
+        try {
+            await initialization;
+        } finally {
+            this.initPromise = null;
+        }
+    }
+
+    private static async initialize(options: SigNozOptions): Promise<void> {
+        const sdkModule = await this.safeImport<any>("@opentelemetry/sdk-node");
+        const traceExporterModule = await this.safeImport<any>("@opentelemetry/exporter-trace-otlp-http");
+        const resourcesModule = await this.safeImport<any>("@opentelemetry/resources");
+        const semanticModule = await this.safeImport<any>("@opentelemetry/semantic-conventions");
+
+        if (!sdkModule?.NodeSDK || !traceExporterModule?.OTLPTraceExporter || !resourcesModule?.Resource || !semanticModule?.SemanticResourceAttributes) {
+            throw new Error(
+                "OpenTelemetry packages are missing. Install '@opentelemetry/sdk-node', '@opentelemetry/exporter-trace-otlp-http', '@opentelemetry/resources' and '@opentelemetry/semantic-conventions'."
+            );
+        }
+
+        const serviceName =
+            options.serviceName ||
+            (Config.get("application.serviceName") as string) ||
+            (Config.get("application.name") as string) ||
+            this.getEnv("SIGNOZ_SERVICE_NAME") ||
+            this.getEnv("OTEL_SERVICE_NAME") ||
+            "webframez-service";
+
+        const environment =
+            options.environment ||
+            (Config.get("application.environment") as string) ||
+            this.getEnv("SIGNOZ_ENVIRONMENT") ||
+            this.getEnv("NODE_ENV") ||
+            "development";
+
+        const traceEndpoint = this.ensureEndpoint(
+            options.endpoint ||
+                this.getEnv("SIGNOZ_ENDPOINT") ||
+                this.getEnv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT") ||
+                this.getEnv("OTEL_EXPORTER_OTLP_ENDPOINT"),
+            "http://localhost:4318",
+            "/v1/traces"
+        );
+
+        const headers = { ...(options.headers || {}) };
+        const apiKey = options.apiKey || this.getEnv("SIGNOZ_API_KEY");
+        if (apiKey && !headers["signoz-access-token"]) {
+            headers["signoz-access-token"] = apiKey;
+        }
+
+        const { NodeSDK } = sdkModule;
+        const { OTLPTraceExporter } = traceExporterModule;
+        const { Resource } = resourcesModule;
+        const { SemanticResourceAttributes } = semanticModule;
+
+        const resourceAttributes: Record<string, unknown> = {
+            [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+            [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: environment,
+        };
+
+        if (options.resourceAttributes) {
+            Object.assign(resourceAttributes, options.resourceAttributes);
+        }
+
+        const resource = new Resource(resourceAttributes);
+
+        let instrumentations = options.instrumentations ? [...options.instrumentations] : [];
+        if (instrumentations.length === 0 && options.autoInstrumentations !== false) {
+            const autoModule = await this.safeImport<any>("@opentelemetry/auto-instrumentations-node");
+            if (autoModule?.getNodeAutoInstrumentations) {
+                instrumentations = [autoModule.getNodeAutoInstrumentations(options.autoInstrumentationConfig || {})];
+            } else {
+                this.warnMissingDependency("@opentelemetry/auto-instrumentations-node");
+            }
+        }
+
+        let traceSampler: any;
+        if (typeof options.samplingRatio === "number") {
+            const samplerModule = await this.safeImport<any>("@opentelemetry/sdk-trace-base");
+            if (samplerModule?.ParentBasedSampler && samplerModule?.TraceIdRatioBasedSampler) {
+                const ratio = Math.min(Math.max(options.samplingRatio, 0), 1);
+                traceSampler = new samplerModule.ParentBasedSampler({
+                    root: new samplerModule.TraceIdRatioBasedSampler(ratio),
+                });
+            } else {
+                this.warnMissingDependency("@opentelemetry/sdk-trace-base");
+            }
+        }
+
+        const traceExporter = new OTLPTraceExporter({
+            url: traceEndpoint,
+            headers,
+        });
+
+        const sdkOptions: any = {
+            resource,
+            traceExporter,
+        };
+
+        if (instrumentations && instrumentations.length > 0) {
+            sdkOptions.instrumentations = instrumentations;
+        }
+        if (traceSampler) {
+            sdkOptions.traceSampler = traceSampler;
+        }
+
+        this.sdk = new NodeSDK(sdkOptions);
+        await this.sdk.start();
+
+        if (options.logInitialization !== false) {
+            this.logInfo(`[SigNoz] Telemetry enabled (service="${serviceName}", endpoint="${traceEndpoint}")`);
+        }
+
+        this.registerShutdownHooks();
+    }
+
+    static async shutdown(): Promise<void> {
+        if (!this.sdk) {
+            return;
+        }
+
+        const sdkToShutdown = this.sdk;
+        this.sdk = null;
+
+        try {
+            await sdkToShutdown.shutdown();
+        } catch (error) {
+            this.logWarn("[SigNoz] Shutdown failed:", error);
+        }
+    }
+
+    private static async safeImport<T = any>(moduleName: string): Promise<T | null> {
+        try {
+            const module = await import(moduleName);
+            return module as T;
+        } catch (error: any) {
+            if (error && (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_MODULE_NOT_FOUND")) {
+                return null;
+            }
+            throw error;
+        }
+    }
+
+    private static ensureEndpoint(value: string | undefined, fallbackHost: string, defaultPath: string): string {
+        const base = value && value.trim() !== "" ? value.trim() : fallbackHost;
+        if (base.includes("/v1/") || base.endsWith(defaultPath)) {
+            return base;
+        }
+        return `${base.replace(/\/$/, "")}${defaultPath}`;
+    }
+
+    private static warnMissingDependency(name: string) {
+        if (this.missingDependencies.has(name)) {
+            return;
+        }
+        this.missingDependencies.add(name);
+        this.logWarn(`[SigNoz] Optional package "${name}" not found. Install it to enable the related feature.`);
+    }
+
+    private static registerShutdownHooks() {
+        if (this.shutdownRegistered) {
+            return;
+        }
+        const nodeProcess = this.getProcess();
+        if (!nodeProcess) {
+            return;
+        }
+        nodeProcess.once("beforeExit", this.shutdownListener);
+        nodeProcess.once("exit", this.shutdownListener);
+        this.shutdownRegistered = true;
+    }
+
+    private static getProcess(): any {
+        if (typeof globalThis === "undefined") {
+            return undefined;
+        }
+        const candidate = (globalThis as any).process;
+        if (candidate && typeof candidate.once === "function") {
+            return candidate;
+        }
+        return undefined;
+    }
+
+    private static getEnv(key: string): string | undefined {
+        const nodeProcess = this.getProcess();
+        if (!nodeProcess || !nodeProcess.env) {
+            return undefined;
+        }
+        const value = nodeProcess.env[key];
+        return typeof value === "string" ? value : undefined;
+    }
+
+    private static getConsole(): any {
+        if (typeof globalThis === "undefined") {
+            return undefined;
+        }
+        return (globalThis as any).console;
+    }
+
+    private static logInfo(...args: unknown[]) {
+        const target = this.getConsole();
+        if (target && typeof target.info === "function") {
+            target.info(...args);
+        }
+    }
+
+    private static logWarn(...args: unknown[]) {
+        const target = this.getConsole();
+        if (target && typeof target.warn === "function") {
+            target.warn(...args);
+        }
+    }
+}

package/src/WebApplication.ts

@@ -1,9 +1,11 @@
+/// <reference types="node" />
 import http, { Server } from "http";
 import { Config } from "./Config";
 import { Router } from "./Router/Router";
 import { QueueJobsRegisty } from "./Queue/QueueJobsRegisty";
 import { DatatableRegistry } from "./Datatable/DatatableRegistry";
 import { ModulesLoader } from "./Modules/ModulesLoader";
+import { SigNozTelemetry } from "./Telemetry/SigNozTelemetry";
 
 export class WebApplication {
     private server!: Server;
@@ -19,6 +21,10 @@ export class WebApplication {
             }
         }
 
+        if (options && options.signoz) {
+            void SigNozTelemetry.init(options.signoz);
+        }
+
         this.modulesLoader = new ModulesLoader();
         this.modulesLoader.load(options && options.modules ? options.modules : []);
 
@@ -45,16 +51,23 @@ export class WebApplication {
         }
 
         const port = options && options.port ? options.port : 3000;
-        this.server = http.createServer((req, res) => {
+        this.server = http.createServer((req: http.IncomingMessage, res: http.ServerResponse) => {
             Router.handleRequest(req, res);
         });
 
+        this.server.on("close", () => {
+            void SigNozTelemetry.shutdown();
+        });
+
         this.server.listen(port, () => {
-            console.log(
-                "Server started and listening on port " +
-                    port +
-                    (options && options.basename ? " (Basename: " + options && options.basename + ")" : "")
-            );
+            const runtimeConsole = typeof globalThis !== "undefined" ? (globalThis as any).console : undefined;
+            if (runtimeConsole && typeof runtimeConsole.log === "function") {
+                runtimeConsole.log(
+                    "Server started and listening on port " +
+                        port +
+                        (options && options.basename ? " (Basename: " + options && options.basename + ")" : "")
+                );
+            }
 
             if (options && options.onBoot) {
                 options.onBoot(port);

package/src/index.ts

@@ -31,4 +31,5 @@ export * from "./Queue/QueueJob";
 export * from "./Queue/QueueJobsRegisty";
 export * from "./Commands/ConsoleOutputHelper";
 export * from "./Modules/ModuleProvider";
+export * from "./Telemetry/SigNozTelemetry";
 export * from "./info";