@application-kit/observability 0.2.0 → 0.3.1

package/dist/esm/health/health.controller.js

@@ -0,0 +1,75 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { runAsInfrastructureQuery } from '@application-kit/typeorm/logging';
+import { Controller, Get, Inject } from '@nestjs/common';
+import { HealthCheck, HealthCheckService, TypeOrmHealthIndicator } from '@nestjs/terminus';
+import { HEALTH_ROUTE } from '../logging/infrastructure-paths.js';
+import { HealthChecks } from './health-checks.js';
+import { MigrationsHealthIndicator } from './migrations.health-indicator.js';
+let HealthController = class HealthController {
+    health;
+    database;
+    migrations;
+    healthChecks;
+    constructor(health, database, migrations, healthChecks) {
+        this.health = health;
+        this.database = database;
+        this.migrations = migrations;
+        this.healthChecks = healthChecks;
+    }
+    async check() {
+        return runAsInfrastructureQuery(async () => this.health.check(this.healthChecks.build()));
+    }
+    async live() {
+        return this.health.check([]);
+    }
+    async ready() {
+        return runAsInfrastructureQuery(async () => this.health.check([
+            async () => this.database.pingCheck('typeorm'),
+            async () => this.migrations.isUpToDate('migrations'),
+        ]));
+    }
+};
+__decorate([
+    Get(),
+    HealthCheck(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "check", null);
+__decorate([
+    Get('live'),
+    HealthCheck(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "live", null);
+__decorate([
+    Get('ready'),
+    HealthCheck(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "ready", null);
+HealthController = __decorate([
+    Controller(HEALTH_ROUTE),
+    __param(0, Inject(HealthCheckService)),
+    __param(1, Inject(TypeOrmHealthIndicator)),
+    __param(2, Inject(MigrationsHealthIndicator)),
+    __param(3, Inject(HealthChecks)),
+    __metadata("design:paramtypes", [HealthCheckService,
+        TypeOrmHealthIndicator,
+        MigrationsHealthIndicator,
+        HealthChecks])
+], HealthController);
+export { HealthController };

package/dist/esm/health/health.environment.d.ts

@@ -0,0 +1,5 @@
+export declare class HealthEnvironment {
+    HEALTH_DISK_THRESHOLD_PERCENT: number;
+    HEALTH_MEMORY_HEAP_MB: number;
+    HEALTH_MEMORY_RSS_MB: number;
+}

package/dist/esm/health/health.environment.js

@@ -0,0 +1,34 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Expose, Type } from 'class-transformer';
+import { IsNumber } from 'class-validator';
+export class HealthEnvironment {
+    HEALTH_DISK_THRESHOLD_PERCENT = 0.8;
+    HEALTH_MEMORY_HEAP_MB = 500;
+    HEALTH_MEMORY_RSS_MB = 800;
+}
+__decorate([
+    Expose(),
+    IsNumber(),
+    Type(() => Number),
+    __metadata("design:type", Object)
+], HealthEnvironment.prototype, "HEALTH_DISK_THRESHOLD_PERCENT", void 0);
+__decorate([
+    Expose(),
+    IsNumber(),
+    Type(() => Number),
+    __metadata("design:type", Object)
+], HealthEnvironment.prototype, "HEALTH_MEMORY_HEAP_MB", void 0);
+__decorate([
+    Expose(),
+    IsNumber(),
+    Type(() => Number),
+    __metadata("design:type", Object)
+], HealthEnvironment.prototype, "HEALTH_MEMORY_RSS_MB", void 0);

package/dist/esm/health/health.module.d.ts

@@ -0,0 +1,5 @@
+import type { DynamicModule } from '@nestjs/common';
+import type { HealthModuleOptionsInterface } from './health-module-options.interface.js';
+export declare class HealthModule {
+    static forRoot(options?: HealthModuleOptionsInterface): DynamicModule;
+}

package/dist/esm/health/health.module.js

@@ -0,0 +1,25 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { HealthChecks } from './health-checks.js';
+let HealthModule = class HealthModule {
+    static forRoot(options = {}) {
+        const terminus = TerminusModule.forRoot(options.terminus);
+        return {
+            exports: [HealthChecks, terminus],
+            global: true,
+            imports: [...options.imports ?? [], terminus],
+            module: this,
+            providers: [HealthChecks],
+        };
+    }
+};
+HealthModule = __decorate([
+    Module({})
+], HealthModule);
+export { HealthModule };

package/dist/esm/health/index.d.ts

@@ -0,0 +1,8 @@
+export * from './health-checks.js';
+export * from './health-http.module.js';
+export * from './health-module-options.interface.js';
+export * from './health.config.js';
+export * from './health.controller.js';
+export * from './health.environment.js';
+export * from './health.module.js';
+export * from './migrations.health-indicator.js';

package/dist/esm/health/index.js

@@ -0,0 +1,8 @@
+export * from './health-checks.js';
+export * from './health-http.module.js';
+export * from './health-module-options.interface.js';
+export * from './health.config.js';
+export * from './health.controller.js';
+export * from './health.environment.js';
+export * from './health.module.js';
+export * from './migrations.health-indicator.js';

package/dist/esm/health/migrations.health-indicator.d.ts

@@ -0,0 +1,9 @@
+import type { HealthIndicatorResult } from '@nestjs/terminus';
+import { HealthIndicatorService } from '@nestjs/terminus';
+import { DataSource } from 'typeorm';
+export declare class MigrationsHealthIndicator {
+    private readonly healthIndicatorService;
+    private readonly dataSource;
+    constructor(healthIndicatorService: HealthIndicatorService, dataSource: DataSource);
+    isUpToDate(key: string): Promise<HealthIndicatorResult>;
+}

package/dist/esm/health/migrations.health-indicator.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from '@nestjs/common';
+import { HealthIndicatorService } from '@nestjs/terminus';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { DataSource } from 'typeorm';
+let MigrationsHealthIndicator = class MigrationsHealthIndicator {
+    healthIndicatorService;
+    dataSource;
+    constructor(healthIndicatorService, dataSource) {
+        this.healthIndicatorService = healthIndicatorService;
+        this.dataSource = dataSource;
+    }
+    async isUpToDate(key) {
+        const hasPendingMigrations = await this.dataSource.showMigrations();
+        const indicator = this.healthIndicatorService.check(key);
+        return hasPendingMigrations ? indicator.down({ pendingMigrations: true }) : indicator.up();
+    }
+};
+MigrationsHealthIndicator = __decorate([
+    Injectable(),
+    __param(0, Inject(HealthIndicatorService)),
+    __param(1, InjectDataSource()),
+    __metadata("design:paramtypes", [HealthIndicatorService,
+        DataSource])
+], MigrationsHealthIndicator);
+export { MigrationsHealthIndicator };

package/dist/esm/logging/index.d.ts

@@ -0,0 +1,8 @@
+export * from './constants.js';
+export * from './infrastructure-paths.js';
+export * from './logger.environment.js';
+export * from './observability-logger.interface.js';
+export * from './pino-logger-options.interface.js';
+export * from './pino-logger.config.js';
+export * from './resolve-request-id.js';
+export * from './resolve-support-id.js';

package/dist/esm/logging/index.js

@@ -0,0 +1,8 @@
+export * from './constants.js';
+export * from './infrastructure-paths.js';
+export * from './logger.environment.js';
+export * from './observability-logger.interface.js';
+export * from './pino-logger-options.interface.js';
+export * from './pino-logger.config.js';
+export * from './resolve-request-id.js';
+export * from './resolve-support-id.js';

package/dist/esm/logging/infrastructure-paths.d.ts

@@ -0,0 +1,4 @@
+export declare const HEALTH_ROUTE = "health";
+export declare const METRICS_ROUTE = "metrics";
+export declare const INFRASTRUCTURE_PATHS: readonly string[];
+export declare const isInfrastructurePath: (path: string) => boolean;

package/dist/esm/logging/infrastructure-paths.js

@@ -0,0 +1,5 @@
+export const HEALTH_ROUTE = 'health';
+export const METRICS_ROUTE = 'metrics';
+export const INFRASTRUCTURE_PATHS = [`/${HEALTH_ROUTE}`, `/${METRICS_ROUTE}`];
+export const isInfrastructurePath = (path) => INFRASTRUCTURE_PATHS
+    .some((prefix) => path === prefix || path.startsWith(`${prefix}/`));

package/dist/esm/logging/logger.environment.d.ts

@@ -0,0 +1,4 @@
+import type { LevelWithSilent } from 'pino';
+export declare class LoggerEnvironment {
+    LOG_LEVEL: LevelWithSilent;
+}

package/dist/esm/logging/logger.environment.js

@@ -0,0 +1,20 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Expose } from 'class-transformer';
+import { IsIn } from 'class-validator';
+const LOG_LEVELS = ['trace', 'debug', 'info', 'warn', 'error', 'fatal', 'silent'];
+export class LoggerEnvironment {
+    LOG_LEVEL = 'warn';
+}
+__decorate([
+    Expose(),
+    IsIn(LOG_LEVELS),
+    __metadata("design:type", String)
+], LoggerEnvironment.prototype, "LOG_LEVEL", void 0);

package/dist/esm/logging/observability-logger.interface.js

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

package/dist/esm/logging/pino-logger-options.interface.d.ts

@@ -0,0 +1,5 @@
+import type { ClientIpSourceInterface } from '../http/resolve-client-ip.js';
+export type ClientIpResolver = (request: ClientIpSourceInterface) => string;
+export interface PinoLoggerOptionsInterface {
+    readonly resolveClientIp?: ClientIpResolver;
+}

package/dist/esm/logging/pino-logger-options.interface.js

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

package/dist/esm/logging/pino-logger.config.d.ts

@@ -0,0 +1,15 @@
+import type { Params } from 'nestjs-pino';
+import type { Level } from 'pino';
+import type { PinoLoggerOptionsInterface } from './pino-logger-options.interface.js';
+import { LoggerEnvironment } from './logger.environment.js';
+export declare const responseLogLevel: (request: {
+    url?: string | undefined;
+}, response: {
+    statusCode: number;
+}, error?: Error) => Level;
+export declare const traceContextMixin: () => Record<string, number | string>;
+export declare class PinoLoggerConfig {
+    private readonly environment;
+    constructor(environment: LoggerEnvironment);
+    createOptions(options?: PinoLoggerOptionsInterface): Params;
+}

package/dist/esm/logging/pino-logger.config.js

@@ -0,0 +1,99 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from '@nestjs/common';
+import { resolveClientIp } from '../http/resolve-client-ip.js';
+import { activeSpanContext } from '../shared/active-span-context.js';
+import { isInfrastructurePath } from './infrastructure-paths.js';
+import { LoggerEnvironment } from './logger.environment.js';
+const HTTP_STATUS_CLIENT_ERROR = 400;
+const HTTP_STATUS_SERVER_ERROR = 500;
+const isInfrastructureRequest = (url) => {
+    const path = url?.split('?', 1)[0];
+    return path !== undefined && isInfrastructurePath(path);
+};
+const failureLevel = (statusCode, error) => {
+    if (error !== undefined || statusCode >= HTTP_STATUS_SERVER_ERROR) {
+        return 'error';
+    }
+    return statusCode >= HTTP_STATUS_CLIENT_ERROR ? 'warn' : undefined;
+};
+export const responseLogLevel = (request, response, error) => failureLevel(response.statusCode, error)
+    ?? (isInfrastructureRequest(request.url) ? 'debug' : 'info');
+export const traceContextMixin = () => {
+    const spanContext = activeSpanContext();
+    if (spanContext === undefined) {
+        return {};
+    }
+    return { span_id: spanContext.spanId, trace_flags: spanContext.traceFlags, trace_id: spanContext.traceId };
+};
+const SEVERITY_BY_LEVEL = {
+    debug: 'DEBUG',
+    error: 'ERROR',
+    fatal: 'CRITICAL',
+    info: 'INFO',
+    trace: 'DEBUG',
+    warn: 'WARNING',
+};
+const REDACTED_LOG_PATHS = [
+    '*.*.password',
+    '*.password',
+    'password',
+    'req.headers.authorization',
+    'req.headers.cookie',
+];
+const rawSocketPort = (request) => request.raw?.socket?.remotePort;
+const remotePort = (request) => request.socket?.remotePort
+    ?? rawSocketPort(request);
+let PinoLoggerConfig = class PinoLoggerConfig {
+    environment;
+    constructor(environment) {
+        this.environment = environment;
+    }
+    createOptions(options = {}) {
+        const clientIp = options.resolveClientIp ?? resolveClientIp;
+        return {
+            pinoHttp: {
+                autoLogging: true,
+                customLogLevel: responseLogLevel,
+                formatters: {
+                    level: (label, number) => ({
+                        level: number,
+                        severity: SEVERITY_BY_LEVEL[label] ?? SEVERITY_BY_LEVEL.info,
+                    }),
+                },
+                level: this.environment.LOG_LEVEL,
+                mixin: traceContextMixin,
+                quietReqLogger: true,
+                redact: [...REDACTED_LOG_PATHS],
+                serializers: {
+                    req: (request) => ({
+                        headers: request.headers,
+                        id: request.id,
+                        method: request.method,
+                        params: request.raw?.params,
+                        query: request.query,
+                        remoteAddress: clientIp(request),
+                        remotePort: remotePort(request),
+                        url: request.url,
+                    }),
+                },
+            },
+        };
+    }
+};
+PinoLoggerConfig = __decorate([
+    Injectable(),
+    __param(0, Inject(LoggerEnvironment)),
+    __metadata("design:paramtypes", [LoggerEnvironment])
+], PinoLoggerConfig);
+export { PinoLoggerConfig };

package/dist/esm/logging/resolve-request-id.d.ts

@@ -0,0 +1,4 @@
+export declare const REQUEST_ID_HEADER = "x-request-id";
+export declare const resolveRequestId: (request: {
+    headers?: Record<string, string | string[] | undefined> | undefined;
+}) => string;

package/dist/esm/logging/resolve-request-id.js

@@ -0,0 +1,6 @@
+import { randomUUID } from 'node:crypto';
+export const REQUEST_ID_HEADER = 'x-request-id';
+export const resolveRequestId = (request) => {
+    const header = request.headers?.[REQUEST_ID_HEADER];
+    return typeof header === 'string' && header !== '' ? header : randomUUID();
+};

package/dist/esm/logging/resolve-support-id.d.ts

@@ -0,0 +1,3 @@
+export declare const resolveSupportId: (request: {
+    id?: string | undefined;
+}) => string;

package/dist/esm/logging/resolve-support-id.js

@@ -0,0 +1,4 @@
+import { activeSpanContext } from '../shared/active-span-context.js';
+export const resolveSupportId = (request) => activeSpanContext()?.traceId
+    ?? request.id
+    ?? '';

package/dist/esm/metrics/index.d.ts

@@ -1,4 +1,7 @@
 export * from './graphql-metrics.js';
 export * from './http-metrics.js';
+export * from './metrics-hooks.js';
 export * from './metrics-http-server.js';
+export * from './metrics-http.module.js';
+export * from './metrics.controller.js';
 export * from './metrics.registry.js';

package/dist/esm/metrics/index.js

@@ -1,4 +1,7 @@
 export * from './graphql-metrics.js';
 export * from './http-metrics.js';
+export * from './metrics-hooks.js';
 export * from './metrics-http-server.js';
+export * from './metrics-http.module.js';
+export * from './metrics.controller.js';
 export * from './metrics.registry.js';

package/dist/esm/metrics/metrics-hooks.d.ts

@@ -0,0 +1,2 @@
+import type { NestFastifyApplication } from '@nestjs/platform-fastify';
+export declare const setupMetricsHooks: (app: NestFastifyApplication) => void;

package/dist/esm/metrics/metrics-hooks.js

@@ -0,0 +1,33 @@
+import { asMercuriusHook, GraphqlMetrics } from './graphql-metrics.js';
+import { HttpMetrics, resolveRouteLabel } from './http-metrics.js';
+const hasMercurius = (fastify) => 'graphql' in fastify;
+const setupGraphqlHooks = (fastify, metrics) => {
+    fastify.addHook('onReady', (done) => {
+        if (hasMercurius(fastify)) {
+            fastify.graphql.addHook('preParsing', asMercuriusHook((_schema, _source, context) => {
+                metrics.start(context);
+            }));
+            fastify.graphql.addHook('preExecution', asMercuriusHook((_schema, document, context) => {
+                metrics.describe(context, document);
+            }));
+            fastify.graphql.addHook('onResolution', asMercuriusHook((result, context) => {
+                metrics.finish(context, (result.errors?.length ?? 0) > 0);
+            }));
+        }
+        done();
+    });
+};
+export const setupMetricsHooks = (app) => {
+    const metrics = app.get(HttpMetrics);
+    const fastify = app.getHttpAdapter().getInstance();
+    fastify.addHook('onResponse', (request, reply, done) => {
+        metrics.observe({
+            durationSeconds: reply.elapsedTime / 1000,
+            method: request.method,
+            route: resolveRouteLabel(request.routeOptions.url),
+            status: reply.statusCode,
+        });
+        done();
+    });
+    setupGraphqlHooks(fastify, app.get(GraphqlMetrics));
+};

package/dist/esm/metrics/metrics-http.module.d.ts

@@ -0,0 +1,5 @@
+import type { DynamicModule } from '@nestjs/common';
+import type { HealthCarrierOptionsInterface } from '../health/health-module-options.interface.js';
+export declare class MetricsHttpModule {
+    static forRoot(options?: HealthCarrierOptionsInterface): DynamicModule;
+}

package/dist/esm/metrics/metrics-http.module.js

@@ -0,0 +1,26 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Module } from '@nestjs/common';
+import { withClassDecorator } from '../shared/with-class-decorator.js';
+import { GraphqlMetrics } from './graphql-metrics.js';
+import { HttpMetrics } from './http-metrics.js';
+import { MetricsController } from './metrics.controller.js';
+import { MetricsRegistry } from './metrics.registry.js';
+let MetricsHttpModule = class MetricsHttpModule {
+    static forRoot(options = {}) {
+        return {
+            controllers: [withClassDecorator(MetricsController, options.publicRoute)],
+            exports: [GraphqlMetrics, HttpMetrics, MetricsRegistry],
+            module: this,
+            providers: [GraphqlMetrics, HttpMetrics, MetricsRegistry],
+        };
+    }
+};
+MetricsHttpModule = __decorate([
+    Module({})
+], MetricsHttpModule);
+export { MetricsHttpModule };

package/dist/esm/metrics/metrics.controller.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyReply } from 'fastify';
+import { MetricsRegistry } from './metrics.registry.js';
+export declare class MetricsController {
+    private readonly metricsRegistry;
+    constructor(metricsRegistry: MetricsRegistry);
+    scrape(reply: FastifyReply): Promise<string>;
+}

package/dist/esm/metrics/metrics.controller.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Get, Header, Inject, Res } from '@nestjs/common';
+import { METRICS_ROUTE } from '../logging/infrastructure-paths.js';
+import { MetricsRegistry } from './metrics.registry.js';
+let MetricsController = class MetricsController {
+    metricsRegistry;
+    constructor(metricsRegistry) {
+        this.metricsRegistry = metricsRegistry;
+    }
+    async scrape(reply) {
+        void reply.header('Content-Type', this.metricsRegistry.contentType);
+        return this.metricsRegistry.render();
+    }
+};
+__decorate([
+    Get(),
+    Header('Cache-Control', 'no-store'),
+    __param(0, Res({ passthrough: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MetricsController.prototype, "scrape", null);
+MetricsController = __decorate([
+    Controller(METRICS_ROUTE),
+    __param(0, Inject(MetricsRegistry)),
+    __metadata("design:paramtypes", [MetricsRegistry])
+], MetricsController);
+export { MetricsController };

package/dist/esm/shared/active-span-context.d.ts

@@ -0,0 +1,2 @@
+import type { SpanContext } from '@opentelemetry/api';
+export declare const activeSpanContext: () => SpanContext | undefined;

package/dist/esm/shared/active-span-context.js

@@ -0,0 +1,5 @@
+import { isSpanContextValid, trace } from '@opentelemetry/api';
+export const activeSpanContext = () => {
+    const spanContext = trace.getActiveSpan()?.spanContext();
+    return spanContext !== undefined && isSpanContextValid(spanContext) ? spanContext : undefined;
+};

package/dist/esm/shared/with-class-decorator.d.ts

@@ -0,0 +1,2 @@
+import type { Type } from '@nestjs/common';
+export declare const withClassDecorator: <T extends Type>(base: T, decorator: ClassDecorator | undefined) => T;

package/dist/esm/shared/with-class-decorator.js

@@ -0,0 +1,10 @@
+export const withClassDecorator = (base, decorator) => {
+    if (decorator === undefined) {
+        return base;
+    }
+    const decorated = class extends base {
+    };
+    Object.defineProperty(decorated, 'name', { value: base.name });
+    decorator(decorated);
+    return decorated;
+};