@breadstone/archipel-platform-telemetry 0.0.12 → 0.0.14

package/README.md

@@ -14,11 +14,12 @@ import { TelemetryModule } from '@breadstone/archipel-platform-telemetry';
 
 ## Features
 
-- Metrics collection
-- Performance tracking
-- Health checks
-- Monitoring integration
-- Custom metrics
+- **Metrics collection**: Counter, histogram, and gauge recording via `TelemetryFacade`
+- **Distributed tracing**: OpenTelemetry SDK integration with automatic span creation
+- **Operation interceptor**: `OperationTelemetryInterceptor` wraps controller methods in telemetry operations (returns `Observable<unknown>`)
+- **Graceful degradation**: Falls back to `NoopTelemetryFacade` when disabled — zero overhead
+- **Health checks**: Integration with health module for observability readiness
+- **Structured logging**: `TelemetryLoggerService` with request correlation IDs
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@breadstone/archipel-platform-telemetry",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "OpenTelemetry integration with tracing, metrics, and graceful no-op fallback for NestJS.",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -28,8 +28,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@breadstone/archipel-platform-caching": "0.0.12",
-    "@breadstone/archipel-platform-core": "0.0.12",
+    "@breadstone/archipel-platform-caching": "0.0.14",
+    "@breadstone/archipel-platform-core": "0.0.14",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/exporter-metrics-otlp-http": "0.215.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.215.0",

package/src/OtelSdkHolder.d.ts

@@ -0,0 +1,19 @@
+import { OnApplicationShutdown } from '@nestjs/common';
+/**
+ * Holds a reference to the OpenTelemetry NodeSDK instance and
+ * performs a graceful shutdown when the application terminates.
+ *
+ * Replaces the former closure-based `otelSdkRef` pattern (TEL-1).
+ *
+ * @public
+ */
+export declare class OtelSdkHolder implements OnApplicationShutdown {
+    private readonly _logger;
+    private _sdk?;
+    /**
+     * Stores the SDK reference so it can be shut down later.
+     */
+    setSdk(sdk: unknown): void;
+    /** @inheritdoc */
+    onApplicationShutdown(): Promise<void>;
+}

package/src/OtelSdkHolder.js

@@ -0,0 +1,49 @@
+"use strict";
+// #region Imports
+var OtelSdkHolder_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelSdkHolder = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+// #endregion
+/**
+ * Holds a reference to the OpenTelemetry NodeSDK instance and
+ * performs a graceful shutdown when the application terminates.
+ *
+ * Replaces the former closure-based `otelSdkRef` pattern (TEL-1).
+ *
+ * @public
+ */
+let OtelSdkHolder = OtelSdkHolder_1 = class OtelSdkHolder {
+    constructor() {
+        // #region Fields
+        this._logger = new common_1.Logger(OtelSdkHolder_1.name);
+        // #endregion
+    }
+    // #endregion
+    // #region Methods
+    /**
+     * Stores the SDK reference so it can be shut down later.
+     */
+    setSdk(sdk) {
+        this._sdk = sdk;
+    }
+    /** @inheritdoc */
+    async onApplicationShutdown() {
+        if (!this._sdk) {
+            return;
+        }
+        try {
+            await this._sdk.shutdown();
+            this._logger.log('OpenTelemetry SDK shut down successfully.');
+        }
+        catch (error) {
+            this._logger.error('Failed to shut down OpenTelemetry SDK.', error.stack);
+        }
+    }
+};
+exports.OtelSdkHolder = OtelSdkHolder;
+exports.OtelSdkHolder = OtelSdkHolder = OtelSdkHolder_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], OtelSdkHolder);
+//# sourceMappingURL=OtelSdkHolder.js.map

package/src/TelemetryModule.js

@@ -5,75 +5,71 @@ exports.TelemetryModule = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
-const TelemetryOptions_1 = require("./options/TelemetryOptions");
-const tokens_1 = require("./tokens");
 const OtelInitializer_1 = require("./bootstrap/OtelInitializer");
 const NoopTelemetryFacade_1 = require("./core/NoopTelemetryFacade");
 const TelemetryFacade_1 = require("./core/TelemetryFacade");
-const TelemetryRuleEngine_1 = require("./rules/TelemetryRuleEngine");
-const TelemetryLoggerService_1 = require("./logger/TelemetryLoggerService");
 const OperationTelemetryInterceptor_1 = require("./interceptor/OperationTelemetryInterceptor");
-const ShutdownHook_1 = require("./ShutdownHook");
+const TelemetryLoggerService_1 = require("./logger/TelemetryLoggerService");
+const MetricsService_1 = require("./metrics/MetricsService");
+const TelemetryOptions_1 = require("./options/TelemetryOptions");
+const OtelSdkHolder_1 = require("./OtelSdkHolder");
+const TelemetryRuleEngine_1 = require("./rules/TelemetryRuleEngine");
+const tokens_1 = require("./tokens");
 let TelemetryModule = TelemetryModule_1 = class TelemetryModule {
     static register(options) {
-        let otelSdkRef;
         return {
             module: TelemetryModule_1,
             providers: [
                 {
                     provide: tokens_1.TELEMETRY_OPTIONS,
-                    useValue: {
-                        ...TelemetryOptions_1.defaultTelemetryOptions,
-                        ...options
-                    }
+                    useFactory: () => {
+                        const merged = {
+                            ...TelemetryOptions_1.defaultTelemetryOptions,
+                            ...options,
+                        };
+                        (0, TelemetryOptions_1.validateTelemetryOptions)(merged);
+                        return merged;
+                    },
                 },
                 {
                     provide: tokens_1.TELEMETRY_ENABLED,
                     inject: [tokens_1.TELEMETRY_OPTIONS],
-                    useFactory: (cfg) => cfg.enabled
+                    useFactory: (cfg) => cfg.enabled,
                 },
                 {
                     provide: TelemetryRuleEngine_1.TelemetryRuleEngine,
-                    inject: [tokens_1.TELEMETRY_OPTIONS],
-                    useFactory: (cfg) => new TelemetryRuleEngine_1.TelemetryRuleEngine(cfg)
+                    inject: [tokens_1.TELEMETRY_OPTIONS, MetricsService_1.MetricsService],
+                    useFactory: (cfg, metricsService) => new TelemetryRuleEngine_1.TelemetryRuleEngine(cfg, metricsService),
                 },
                 TelemetryLoggerService_1.TelemetryLoggerService,
-                ShutdownHook_1.TelemetryShutdownHook,
+                OtelSdkHolder_1.OtelSdkHolder,
+                MetricsService_1.MetricsService,
                 {
                     provide: tokens_1.TELEMETRY_FACADE,
-                    inject: [tokens_1.TELEMETRY_OPTIONS, tokens_1.TELEMETRY_ENABLED],
-                    useFactory: async (cfg, enabled) => {
+                    inject: [tokens_1.TELEMETRY_OPTIONS, tokens_1.TELEMETRY_ENABLED, OtelSdkHolder_1.OtelSdkHolder],
+                    useFactory: async (cfg, enabled, sdkHolder) => {
                         if (!enabled)
                             return new NoopTelemetryFacade_1.NoopTelemetryFacade();
                         try {
                             const { sdk } = await (0, OtelInitializer_1.initializeOtel)(cfg);
-                            otelSdkRef = sdk;
+                            sdkHolder.setSdk(sdk);
                             return new TelemetryFacade_1.TelemetryFacade();
                         }
-                        catch {
+                        catch (error) {
+                            new common_1.Logger('TelemetryModule').error('OpenTelemetry SDK initialization failed, falling back to noop', error.stack);
                             return new NoopTelemetryFacade_1.NoopTelemetryFacade();
                         }
-                    }
-                },
-                {
-                    provide: tokens_1.TELEMETRY_SHUTDOWN,
-                    inject: [tokens_1.TELEMETRY_ENABLED],
-                    useFactory: (enabled) => async () => {
-                        if (enabled) {
-                            try {
-                                await otelSdkRef?.shutdown?.();
-                            }
-                            catch { /* noop */ }
-                        }
-                    }
+                    },
                 },
                 {
                     provide: core_1.APP_INTERCEPTOR,
                     inject: [tokens_1.TELEMETRY_FACADE, tokens_1.TELEMETRY_OPTIONS],
-                    useFactory: (facade, cfg) => cfg.interceptor?.operation ? new OperationTelemetryInterceptor_1.OperationTelemetryInterceptor(facade) : { intercept: (_, handler) => handler }
-                }
+                    useFactory: (facade, cfg) => cfg.interceptor?.operation
+                        ? new OperationTelemetryInterceptor_1.OperationTelemetryInterceptor(facade)
+                        : { intercept: (_, next) => next.handle() },
+                },
             ],
-            exports: [tokens_1.TELEMETRY_FACADE]
+            exports: [tokens_1.TELEMETRY_FACADE, MetricsService_1.MetricsService],
         };
     }
 };

package/src/bootstrap/OtelInitializer.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeOtel = initializeOtel;
+const common_1 = require("@nestjs/common");
+const logger = new common_1.Logger('OtelInitializer');
 // Lazy initialization to avoid module load costs when disabled
 async function initializeOtel(options) {
     if (!options.enabled)
@@ -28,23 +30,25 @@ async function initializeOtel(options) {
             const metricExp = require('@opentelemetry/exporter-metrics-otlp-http');
             metricReader = new sdkNode.PeriodicExportingMetricReader({
                 exporter: new metricExp.OTLPMetricExporter(),
-                exportIntervalMillis: options.metrics?.intervalMs ?? 60000
+                exportIntervalMillis: options.metrics?.intervalMs ?? 60000,
             });
         }
         const resource = new resources.Resource({
             [semconv.SemanticResourceAttributes.SERVICE_NAME]: options.serviceName,
-            environment: options.environment ?? 'local'
+            environment: options.environment ?? 'local',
         });
         const sdk = new sdkNode.NodeSDK({
             resource,
             traceExporter,
             metricReader,
-            instrumentations
+            instrumentations,
         });
         await sdk.start();
+        logger.log('OpenTelemetry SDK initialized successfully.');
         return { sdk };
     }
-    catch {
+    catch (error) {
+        logger.error('Failed to initialize OpenTelemetry SDK. Telemetry will be degraded.', error.stack);
         return {};
     }
 }

package/src/core/TelemetryFacade.d.ts

@@ -1,7 +1,8 @@
-import { ITelemetryFacade } from './NoopTelemetryFacade';
 import { Logger } from '@nestjs/common';
+import { ITelemetryFacade } from './NoopTelemetryFacade';
 export declare class TelemetryFacade implements ITelemetryFacade {
     private readonly _logger;
+    constructor(logger?: Logger);
     runOperation<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
     recordCacheEvent(event: {
         cache: string;

package/src/core/TelemetryFacade.js

@@ -3,9 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryFacade = void 0;
 const common_1 = require("@nestjs/common");
 class TelemetryFacade {
-    constructor() {
-        this._logger = new common_1.Logger('TelemetryFacade');
+    // #endregion
+    // #region Ctor
+    constructor(logger) {
+        this._logger = logger ?? new common_1.Logger(TelemetryFacade.name);
     }
+    // #endregion
+    // #region Methods
     async runOperation(name, fn) {
         const start = Date.now();
         try {
@@ -25,12 +29,15 @@ class TelemetryFacade {
     }
     recordClientMetric(name, type, value, labels) {
         const labelStr = labels
-            ? Object.entries(labels).map(([k, v]) => `${k}=${v}`)
+            ? Object.entries(labels)
+                .map(([k, v]) => `${k}=${v}`)
                 .join(' ')
             : '';
         this._logger.debug(`client.metric name=${name} type=${type} value=${value}${labelStr ? ' ' + labelStr : ''}`);
     }
-    getLogger() { return this._logger; }
+    getLogger() {
+        return this._logger;
+    }
 }
 exports.TelemetryFacade = TelemetryFacade;
 //# sourceMappingURL=TelemetryFacade.js.map

package/src/index.d.ts

@@ -1,8 +1,10 @@
-export { TelemetryModule } from './TelemetryModule';
 export * from './core/NoopTelemetryFacade';
-export * from './core/TelemetryFacade';
 export * from './core/TelemetryCacheMetricsRecorder';
-export * from './rules/TelemetryRuleEngine';
+export * from './core/TelemetryFacade';
 export * from './logger/TelemetryLoggerService';
+export * from './metrics/MetricsService';
 export * from './options/TelemetryOptions';
+export { OtelSdkHolder } from './OtelSdkHolder';
+export * from './rules/TelemetryRuleEngine';
+export { TelemetryModule } from './TelemetryModule';
 export * from './tokens';

package/src/index.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelemetryModule = void 0;
+exports.TelemetryModule = exports.OtelSdkHolder = void 0;
 const tslib_1 = require("tslib");
-var TelemetryModule_1 = require("./TelemetryModule");
-Object.defineProperty(exports, "TelemetryModule", { enumerable: true, get: function () { return TelemetryModule_1.TelemetryModule; } });
 tslib_1.__exportStar(require("./core/NoopTelemetryFacade"), exports);
-tslib_1.__exportStar(require("./core/TelemetryFacade"), exports);
 tslib_1.__exportStar(require("./core/TelemetryCacheMetricsRecorder"), exports);
-tslib_1.__exportStar(require("./rules/TelemetryRuleEngine"), exports);
+tslib_1.__exportStar(require("./core/TelemetryFacade"), exports);
 tslib_1.__exportStar(require("./logger/TelemetryLoggerService"), exports);
+tslib_1.__exportStar(require("./metrics/MetricsService"), exports);
 tslib_1.__exportStar(require("./options/TelemetryOptions"), exports);
+var OtelSdkHolder_1 = require("./OtelSdkHolder");
+Object.defineProperty(exports, "OtelSdkHolder", { enumerable: true, get: function () { return OtelSdkHolder_1.OtelSdkHolder; } });
+tslib_1.__exportStar(require("./rules/TelemetryRuleEngine"), exports);
+var TelemetryModule_1 = require("./TelemetryModule");
+Object.defineProperty(exports, "TelemetryModule", { enumerable: true, get: function () { return TelemetryModule_1.TelemetryModule; } });
 tslib_1.__exportStar(require("./tokens"), exports);
 //# sourceMappingURL=index.js.map

package/src/interceptor/OperationTelemetryInterceptor.d.ts

@@ -4,5 +4,5 @@ import { ITelemetryFacade } from '../core/NoopTelemetryFacade';
 export declare class OperationTelemetryInterceptor implements NestInterceptor {
     private readonly _facade;
     constructor(facade: ITelemetryFacade);
-    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> | Promise<Observable<unknown>>;
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
 }

package/src/interceptor/OperationTelemetryInterceptor.js

@@ -7,14 +7,16 @@ const rxjs_1 = require("rxjs");
 let OperationTelemetryInterceptor = class OperationTelemetryInterceptor {
     // #endregion
     // #region Ctor
-    constructor(facade) { this._facade = facade; }
+    constructor(facade) {
+        this._facade = facade;
+    }
     // #endregion
     // #region Methods
     intercept(context, next) {
         const handler = context.getHandler().name;
         const cls = context.getClass().name;
         const name = `${cls}.${handler}`;
-        return this._facade.runOperation(name, async () => await (0, rxjs_1.firstValueFrom)(next.handle()));
+        return (0, rxjs_1.from)(this._facade.runOperation(name, () => (0, rxjs_1.firstValueFrom)(next.handle())));
     }
 };
 exports.OperationTelemetryInterceptor = OperationTelemetryInterceptor;

package/src/metrics/MetricsService.d.ts

@@ -0,0 +1,20 @@
+export interface IMetricInstruments {
+    cacheCounter?: unknown;
+    opCounter?: unknown;
+    opDuration?: unknown;
+}
+/**
+ * Provides lazily-initialized OpenTelemetry metric instruments.
+ *
+ * Replaces the former module-level `let instruments` closure (TEL-4).
+ *
+ * @public
+ */
+export declare class MetricsService {
+    private readonly _logger;
+    private _instruments?;
+    /**
+     * Returns the cached metric instruments, creating them on first access.
+     */
+    getInstruments(): IMetricInstruments | undefined;
+}

package/src/metrics/MetricsService.js

@@ -0,0 +1,51 @@
+"use strict";
+// #region Imports
+var MetricsService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+// #endregion
+/**
+ * Provides lazily-initialized OpenTelemetry metric instruments.
+ *
+ * Replaces the former module-level `let instruments` closure (TEL-4).
+ *
+ * @public
+ */
+let MetricsService = MetricsService_1 = class MetricsService {
+    constructor() {
+        // #region Fields
+        this._logger = new common_1.Logger(MetricsService_1.name);
+        // #endregion
+    }
+    // #endregion
+    // #region Methods
+    /**
+     * Returns the cached metric instruments, creating them on first access.
+     */
+    getInstruments() {
+        if (this._instruments) {
+            return this._instruments;
+        }
+        try {
+            const api = require('@opentelemetry/api');
+            const meter = api.metrics.getMeter('telemetry');
+            this._instruments = {
+                cacheCounter: meter.createCounter('cache_event_total', { description: 'Cache events (hit/miss/save)' }),
+                opCounter: meter.createCounter('operation_event_total', { description: 'Operation success/error events' }),
+                opDuration: meter.createHistogram('operation_duration_ms', { description: 'Operation durations ms' }),
+            };
+            return this._instruments;
+        }
+        catch (error) {
+            this._logger.warn('Failed to initialize metric instruments.', error.message);
+            return undefined;
+        }
+    }
+};
+exports.MetricsService = MetricsService;
+exports.MetricsService = MetricsService = MetricsService_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], MetricsService);
+//# sourceMappingURL=MetricsService.js.map

package/src/options/TelemetryOptions.d.ts

@@ -28,3 +28,7 @@ export interface ITelemetryOptions {
     };
 }
 export declare const defaultTelemetryOptions: ITelemetryOptions;
+/**
+ * Validates telemetry options and throws on invalid values.
+ */
+export declare function validateTelemetryOptions(options: ITelemetryOptions): void;

package/src/options/TelemetryOptions.js

@@ -2,31 +2,48 @@
 // #region Interfaces
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTelemetryOptions = void 0;
+exports.validateTelemetryOptions = validateTelemetryOptions;
 exports.defaultTelemetryOptions = {
     enabled: true,
     serviceName: 'app',
     traces: {
         enabled: true,
         samplingRatio: 0.05,
-        exporter: 'otlp-http'
+        exporter: 'otlp-http',
     },
     metrics: {
         enabled: true,
         intervalMs: 60000,
-        exporter: 'otlp-http'
+        exporter: 'otlp-http',
     },
     logCorrelation: true,
     instrumentation: {
         http: true,
-        express: true
+        express: true,
     },
     pattern: {
         enableCacheMetrics: true,
-        enableOperationMetrics: true
+        enableOperationMetrics: true,
     },
     interceptor: {
-        operation: true
-    }
+        operation: true,
+    },
 };
+/**
+ * Validates telemetry options and throws on invalid values.
+ */
+function validateTelemetryOptions(options) {
+    if (options.enabled && (!options.serviceName || options.serviceName.trim().length === 0)) {
+        throw new Error('TelemetryOptions: serviceName must be a non-empty string when telemetry is enabled.');
+    }
+    const ratio = options.traces?.samplingRatio;
+    if (ratio !== undefined && (ratio < 0 || ratio > 1)) {
+        throw new Error(`TelemetryOptions: traces.samplingRatio must be between 0 and 1, got ${ratio}.`);
+    }
+    const interval = options.metrics?.intervalMs;
+    if (interval !== undefined && interval <= 0) {
+        throw new Error(`TelemetryOptions: metrics.intervalMs must be positive, got ${interval}.`);
+    }
+}
 // #endregion
 //# sourceMappingURL=TelemetryOptions.js.map

package/src/rules/TelemetryRuleEngine.d.ts

@@ -1,7 +1,9 @@
+import { MetricsService } from '../metrics/MetricsService';
 import { ITelemetryOptions } from '../options/TelemetryOptions';
 export declare class TelemetryRuleEngine {
     private readonly _options;
-    constructor(options: ITelemetryOptions);
+    private readonly _metricsService;
+    constructor(options: ITelemetryOptions, metricsService: MetricsService);
     process(message: string): void;
     private handleCache;
     private handleOperation;

package/src/rules/TelemetryRuleEngine.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryRuleEngine = void 0;
-const MetricsHelper_1 = require("../metrics/MetricsHelper");
 class TelemetryRuleEngine {
     // #endregion
     // #region Ctor
-    constructor(options) { this._options = options; }
+    constructor(options, metricsService) {
+        this._options = options;
+        this._metricsService = metricsService;
+    }
     // #endregion
     // #region Methods
     process(message) {
@@ -24,7 +26,7 @@ class TelemetryRuleEngine {
         if (!this._options.pattern?.enableCacheMetrics)
             return;
         const tokens = this.parseTokens(line);
-        const instruments = (0, MetricsHelper_1.getInstruments)();
+        const instruments = this._metricsService.getInstruments();
         const counter = instruments?.cacheCounter;
         if (!counter)
             return;
@@ -32,67 +34,68 @@ class TelemetryRuleEngine {
             counter.add(1, {
                 cache: tokens['cache'] ?? 'unknown',
                 outcome: tokens['outcome'] ?? 'unknown',
-                phase: tokens['phase'] ?? 'none'
+                phase: tokens['phase'] ?? 'none',
             });
         }
-        catch { /* noop */ }
+        catch {
+            /* noop */
+        }
     }
     handleOperation(line) {
         if (!this._options.pattern?.enableOperationMetrics)
             return;
         const success = line.startsWith('op.success');
         const tokens = this.parseTokens(line);
-        const instruments = (0, MetricsHelper_1.getInstruments)();
+        const instruments = this._metricsService.getInstruments();
         if (!instruments)
             return;
         const counter = instruments.opCounter;
         const histogram = instruments.opDuration;
         const labels = {
             name: tokens['name'] ?? 'unknown',
-            status: success ? 'success' : 'error'
+            status: success ? 'success' : 'error',
         };
         try {
             counter?.add(1, labels);
         }
-        catch { /* noop */ }
+        catch {
+            /* noop */
+        }
         const dur = tokens['duration_ms'] ? Number(tokens['duration_ms']) : undefined;
         if (dur !== undefined && !Number.isNaN(dur)) {
             try {
                 histogram?.record(dur, labels);
             }
-            catch { /* noop */ }
+            catch {
+                /* noop */
+            }
         }
     }
     handleClientMetric(line) {
-        // Always enabled if arrives; client submission is already filtered front-side.
         const tokens = this.parseTokens(line);
-        const instruments = (0, MetricsHelper_1.getInstruments)();
+        const instruments = this._metricsService.getInstruments();
         if (!instruments)
             return;
-        const counter = instruments.opCounter; // reuse op counter; could separate later.
+        const counter = instruments.opCounter;
         const histogram = instruments.opDuration;
         const name = tokens['name'] ?? 'unknown';
         const valueRaw = tokens['value'] ? Number(tokens['value']) : undefined;
         const type = tokens['type'] ?? 'counter';
-        const baseLabels = {
-            source: 'client',
-            name
-        };
+        const baseLabels = { source: 'client', name };
         try {
             if (type === 'counter') {
                 counter?.add(1, baseLabels);
             }
             else if (type === 'gauge' && valueRaw !== undefined && !Number.isNaN(valueRaw)) {
-                histogram?.record(valueRaw, {
-                    ...baseLabels,
-                    gauge: true
-                });
+                histogram?.record(valueRaw, { ...baseLabels, gauge: true });
             }
             else if (type === 'histogram' && valueRaw !== undefined && !Number.isNaN(valueRaw)) {
                 histogram?.record(valueRaw, baseLabels);
             }
         }
-        catch { /* noop */ }
+        catch {
+            /* noop */
+        }
     }
     parseTokens(line) {
         const parts = line.split(/\s+/).slice(1);

package/src/tokens.d.ts

@@ -1,4 +1,3 @@
 export declare const TELEMETRY_OPTIONS: unique symbol;
 export declare const TELEMETRY_FACADE: unique symbol;
 export declare const TELEMETRY_ENABLED: unique symbol;
-export declare const TELEMETRY_SHUTDOWN: unique symbol;

package/src/tokens.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TELEMETRY_SHUTDOWN = exports.TELEMETRY_ENABLED = exports.TELEMETRY_FACADE = exports.TELEMETRY_OPTIONS = void 0;
+exports.TELEMETRY_ENABLED = exports.TELEMETRY_FACADE = exports.TELEMETRY_OPTIONS = void 0;
 // Internal DI tokens (not exposing OTel types)
 exports.TELEMETRY_OPTIONS = Symbol('TELEMETRY_OPTIONS');
 exports.TELEMETRY_FACADE = Symbol('TELEMETRY_FACADE');
 exports.TELEMETRY_ENABLED = Symbol('TELEMETRY_ENABLED');
-exports.TELEMETRY_SHUTDOWN = Symbol('TELEMETRY_SHUTDOWN');
 //# sourceMappingURL=tokens.js.map

package/src/ShutdownHook.d.ts

@@ -1,6 +0,0 @@
-import { OnApplicationShutdown } from '@nestjs/common';
-export declare class TelemetryShutdownHook implements OnApplicationShutdown {
-    private readonly _shutdown;
-    constructor(shutdown: () => Promise<void>);
-    onApplicationShutdown(): Promise<void>;
-}

package/src/ShutdownHook.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelemetryShutdownHook = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const tokens_1 = require("./tokens");
-let TelemetryShutdownHook = class TelemetryShutdownHook {
-    // #endregion
-    // #region Ctor
-    constructor(shutdown) { this._shutdown = shutdown; }
-    // #endregion
-    // #region Methods
-    async onApplicationShutdown() { await this._shutdown(); }
-};
-exports.TelemetryShutdownHook = TelemetryShutdownHook;
-exports.TelemetryShutdownHook = TelemetryShutdownHook = tslib_1.__decorate([
-    (0, common_1.Injectable)(),
-    tslib_1.__param(0, (0, common_1.Inject)(tokens_1.TELEMETRY_SHUTDOWN)),
-    tslib_1.__metadata("design:paramtypes", [Function])
-], TelemetryShutdownHook);
-//# sourceMappingURL=ShutdownHook.js.map

package/src/metrics/MetricsHelper.d.ts

@@ -1,6 +0,0 @@
-export interface IMetricInstruments {
-    cacheCounter?: unknown;
-    opCounter?: unknown;
-    opDuration?: unknown;
-}
-export declare function getInstruments(): IMetricInstruments | undefined;

package/src/metrics/MetricsHelper.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInstruments = getInstruments;
-let instruments;
-function getInstruments() {
-    if (instruments)
-        return instruments;
-    try {
-        const api = require('@opentelemetry/api');
-        const meter = api.metrics.getMeter('telemetry');
-        instruments = {
-            cacheCounter: meter.createCounter('cache_event_total', { description: 'Cache events (hit/miss/save)' }),
-            opCounter: meter.createCounter('operation_event_total', { description: 'Operation success/error events' }),
-            opDuration: meter.createHistogram('operation_duration_ms', { description: 'Operation durations ms' })
-        };
-        return instruments;
-    }
-    catch {
-        return undefined;
-    }
-}
-//# sourceMappingURL=MetricsHelper.js.map