@application-kit/observability 0.1.0 → 0.3.0

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

@@ -0,0 +1,104 @@
+"use strict";
+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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinoLoggerConfig = exports.traceContextMixin = exports.responseLogLevel = void 0;
+const common_1 = require("@nestjs/common");
+const resolve_client_ip_js_1 = require("../http/resolve-client-ip.js");
+const active_span_context_js_1 = require("../shared/active-span-context.js");
+const infrastructure_paths_js_1 = require("./infrastructure-paths.js");
+const logger_environment_js_1 = require("./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 && (0, infrastructure_paths_js_1.isInfrastructurePath)(path);
+};
+const failureLevel = (statusCode, error) => {
+    if (error !== undefined || statusCode >= HTTP_STATUS_SERVER_ERROR) {
+        return 'error';
+    }
+    return statusCode >= HTTP_STATUS_CLIENT_ERROR ? 'warn' : undefined;
+};
+const responseLogLevel = (request, response, error) => failureLevel(response.statusCode, error)
+    ?? (isInfrastructureRequest(request.url) ? 'debug' : 'info');
+exports.responseLogLevel = responseLogLevel;
+const traceContextMixin = () => {
+    const spanContext = (0, active_span_context_js_1.activeSpanContext)();
+    if (spanContext === undefined) {
+        return {};
+    }
+    return { span_id: spanContext.spanId, trace_flags: spanContext.traceFlags, trace_id: spanContext.traceId };
+};
+exports.traceContextMixin = traceContextMixin;
+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 ?? resolve_client_ip_js_1.resolveClientIp;
+        return {
+            pinoHttp: {
+                autoLogging: true,
+                customLogLevel: exports.responseLogLevel,
+                formatters: {
+                    level: (label, number) => ({
+                        level: number,
+                        severity: SEVERITY_BY_LEVEL[label] ?? SEVERITY_BY_LEVEL.info,
+                    }),
+                },
+                level: this.environment.LOG_LEVEL,
+                mixin: exports.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,
+                    }),
+                },
+            },
+        };
+    }
+};
+exports.PinoLoggerConfig = PinoLoggerConfig;
+exports.PinoLoggerConfig = PinoLoggerConfig = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(logger_environment_js_1.LoggerEnvironment)),
+    __metadata("design:paramtypes", [logger_environment_js_1.LoggerEnvironment])
+], PinoLoggerConfig);

package/dist/cjs/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/cjs/logging/resolve-request-id.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRequestId = exports.REQUEST_ID_HEADER = void 0;
+const node_crypto_1 = require("node:crypto");
+exports.REQUEST_ID_HEADER = 'x-request-id';
+const resolveRequestId = (request) => {
+    const header = request.headers?.[exports.REQUEST_ID_HEADER];
+    return typeof header === 'string' && header !== '' ? header : (0, node_crypto_1.randomUUID)();
+};
+exports.resolveRequestId = resolveRequestId;

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

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

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSupportId = void 0;
+const active_span_context_js_1 = require("../shared/active-span-context.js");
+const resolveSupportId = (request) => (0, active_span_context_js_1.activeSpanContext)()?.traceId
+    ?? request.id
+    ?? '';
+exports.resolveSupportId = resolveSupportId;

package/dist/cjs/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/cjs/metrics/index.js

@@ -16,5 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./graphql-metrics.js"), exports);
 __exportStar(require("./http-metrics.js"), exports);
+__exportStar(require("./metrics-hooks.js"), exports);
 __exportStar(require("./metrics-http-server.js"), exports);
+__exportStar(require("./metrics-http.module.js"), exports);
+__exportStar(require("./metrics.controller.js"), exports);
 __exportStar(require("./metrics.registry.js"), exports);

package/dist/cjs/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/cjs/metrics/metrics-hooks.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupMetricsHooks = void 0;
+const graphql_metrics_js_1 = require("./graphql-metrics.js");
+const http_metrics_js_1 = require("./http-metrics.js");
+const hasMercurius = (fastify) => 'graphql' in fastify;
+const setupGraphqlHooks = (fastify, metrics) => {
+    fastify.addHook('onReady', (done) => {
+        if (hasMercurius(fastify)) {
+            fastify.graphql.addHook('preParsing', (0, graphql_metrics_js_1.asMercuriusHook)((_schema, _source, context) => {
+                metrics.start(context);
+            }));
+            fastify.graphql.addHook('preExecution', (0, graphql_metrics_js_1.asMercuriusHook)((_schema, document, context) => {
+                metrics.describe(context, document);
+            }));
+            fastify.graphql.addHook('onResolution', (0, graphql_metrics_js_1.asMercuriusHook)((result, context) => {
+                metrics.finish(context, (result.errors?.length ?? 0) > 0);
+            }));
+        }
+        done();
+    });
+};
+const setupMetricsHooks = (app) => {
+    const metrics = app.get(http_metrics_js_1.HttpMetrics);
+    const fastify = app.getHttpAdapter().getInstance();
+    fastify.addHook('onResponse', (request, reply, done) => {
+        metrics.observe({
+            durationSeconds: reply.elapsedTime / 1000,
+            method: request.method,
+            route: (0, http_metrics_js_1.resolveRouteLabel)(request.routeOptions.url),
+            status: reply.statusCode,
+        });
+        done();
+    });
+    setupGraphqlHooks(fastify, app.get(graphql_metrics_js_1.GraphqlMetrics));
+};
+exports.setupMetricsHooks = setupMetricsHooks;

package/dist/cjs/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/cjs/metrics/metrics-http.module.js

@@ -0,0 +1,29 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsHttpModule = void 0;
+const common_1 = require("@nestjs/common");
+const with_class_decorator_js_1 = require("../shared/with-class-decorator.js");
+const graphql_metrics_js_1 = require("./graphql-metrics.js");
+const http_metrics_js_1 = require("./http-metrics.js");
+const metrics_controller_js_1 = require("./metrics.controller.js");
+const metrics_registry_js_1 = require("./metrics.registry.js");
+let MetricsHttpModule = class MetricsHttpModule {
+    static forRoot(options = {}) {
+        return {
+            controllers: [(0, with_class_decorator_js_1.withClassDecorator)(metrics_controller_js_1.MetricsController, options.publicRoute)],
+            exports: [graphql_metrics_js_1.GraphqlMetrics, http_metrics_js_1.HttpMetrics, metrics_registry_js_1.MetricsRegistry],
+            module: this,
+            providers: [graphql_metrics_js_1.GraphqlMetrics, http_metrics_js_1.HttpMetrics, metrics_registry_js_1.MetricsRegistry],
+        };
+    }
+};
+exports.MetricsHttpModule = MetricsHttpModule;
+exports.MetricsHttpModule = MetricsHttpModule = __decorate([
+    (0, common_1.Module)({})
+], MetricsHttpModule);

package/dist/cjs/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/cjs/metrics/metrics.controller.js

@@ -0,0 +1,42 @@
+"use strict";
+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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsController = void 0;
+const common_1 = require("@nestjs/common");
+const infrastructure_paths_js_1 = require("../logging/infrastructure-paths.js");
+const metrics_registry_js_1 = require("./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();
+    }
+};
+exports.MetricsController = MetricsController;
+__decorate([
+    (0, common_1.Get)(),
+    (0, common_1.Header)('Cache-Control', 'no-store'),
+    __param(0, (0, common_1.Res)({ passthrough: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MetricsController.prototype, "scrape", null);
+exports.MetricsController = MetricsController = __decorate([
+    (0, common_1.Controller)(infrastructure_paths_js_1.METRICS_ROUTE),
+    __param(0, (0, common_1.Inject)(metrics_registry_js_1.MetricsRegistry)),
+    __metadata("design:paramtypes", [metrics_registry_js_1.MetricsRegistry])
+], MetricsController);

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

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

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activeSpanContext = void 0;
+const api_1 = require("@opentelemetry/api");
+const activeSpanContext = () => {
+    const spanContext = api_1.trace.getActiveSpan()?.spanContext();
+    return spanContext !== undefined && (0, api_1.isSpanContextValid)(spanContext) ? spanContext : undefined;
+};
+exports.activeSpanContext = activeSpanContext;

package/dist/cjs/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/cjs/shared/with-class-decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withClassDecorator = void 0;
+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;
+};
+exports.withClassDecorator = withClassDecorator;

package/dist/esm/cqrs/cqrs-logger.d.ts

@@ -0,0 +1,12 @@
+import { OnApplicationBootstrap } from '@nestjs/common';
+import { CommandBus, QueryBus } from '@nestjs/cqrs';
+import type { ObservabilityLoggerInterface } from '../logging/observability-logger.interface.js';
+export declare class CqrsLogger implements OnApplicationBootstrap {
+    private readonly commandBus;
+    private readonly queryBus;
+    private readonly logger;
+    private instrumented;
+    constructor(commandBus: CommandBus, queryBus: QueryBus, logger: ObservabilityLoggerInterface);
+    onApplicationBootstrap(): void;
+    private instrumentCompletion;
+}

package/dist/esm/cqrs/cqrs-logger.js

@@ -0,0 +1,69 @@
+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 { CommandBus, QueryBus } from '@nestjs/cqrs';
+import { performance } from 'node:perf_hooks';
+import { OBSERVABILITY_LOGGER } from '../logging/constants.js';
+const KIND_COMMAND = 'command';
+const KIND_QUERY = 'query';
+let CqrsLogger = class CqrsLogger {
+    commandBus;
+    queryBus;
+    logger;
+    instrumented = false;
+    constructor(commandBus, queryBus, logger) {
+        this.commandBus = commandBus;
+        this.queryBus = queryBus;
+        this.logger = logger;
+    }
+    onApplicationBootstrap() {
+        if (this.instrumented) {
+            return;
+        }
+        this.instrumented = true;
+        this.commandBus.subscribe((command) => {
+            this.logger.info({ [KIND_COMMAND]: command.constructor.name }, 'command started');
+        });
+        this.queryBus.subscribe((query) => {
+            this.logger.info({ [KIND_QUERY]: query.constructor.name }, 'query started');
+        });
+        this.instrumentCompletion(this.commandBus, KIND_COMMAND);
+        this.instrumentCompletion(this.queryBus, KIND_QUERY);
+    }
+    instrumentCompletion(bus, kind) {
+        const target = bus;
+        const original = target.execute.bind(target);
+        target.execute = async (payload, context) => {
+            const startedAt = performance.now();
+            const { name } = payload.constructor;
+            try {
+                const result = await original(payload, context);
+                this.logger.info({ durationMs: performance.now() - startedAt, [kind]: name, outcome: 'ok' }, `${kind} finished`);
+                return result;
+            }
+            catch (error) {
+                this.logger.error({ durationMs: performance.now() - startedAt, err: error, [kind]: name, outcome: 'error' }, `${kind} failed`);
+                throw error;
+            }
+        };
+    }
+};
+CqrsLogger = __decorate([
+    Injectable(),
+    __param(0, Inject(CommandBus)),
+    __param(1, Inject(QueryBus)),
+    __param(2, Inject(OBSERVABILITY_LOGGER)),
+    __metadata("design:paramtypes", [CommandBus,
+        QueryBus, Object])
+], CqrsLogger);
+export { CqrsLogger };

package/dist/esm/cqrs/cqrs-logger.module.d.ts

@@ -0,0 +1,2 @@
+export declare class CqrsLoggerModule {
+}

package/dist/esm/cqrs/cqrs-logger.module.js

@@ -0,0 +1,19 @@
+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 { CqrsModule } from '@nestjs/cqrs';
+import { CqrsLogger } from './cqrs-logger.js';
+let CqrsLoggerModule = class CqrsLoggerModule {
+};
+CqrsLoggerModule = __decorate([
+    Module({
+        exports: [CqrsLogger],
+        imports: [CqrsModule],
+        providers: [CqrsLogger],
+    })
+], CqrsLoggerModule);
+export { CqrsLoggerModule };

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

@@ -0,0 +1,2 @@
+export * from './cqrs-logger.js';
+export * from './cqrs-logger.module.js';

package/dist/esm/cqrs/index.js

@@ -0,0 +1,2 @@
+export * from './cqrs-logger.js';
+export * from './cqrs-logger.module.js';

package/dist/esm/health/cli/health-cli-options.interface.d.ts

@@ -0,0 +1,3 @@
+export interface HealthCliOptionsInterface {
+    readonly command: string;
+}

package/dist/esm/health/cli/health-cli-options.interface.js

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

package/dist/esm/health/cli/health-cli.d.ts

@@ -0,0 +1,13 @@
+import type { Type } from '@nestjs/common';
+import { HealthCheckService } from '@nestjs/terminus';
+import type { ObservabilityLoggerInterface } from '../../logging/observability-logger.interface.js';
+import type { HealthCliOptionsInterface } from './health-cli-options.interface.js';
+import { HealthChecks } from '../health-checks.js';
+export declare class HealthCliCommands {
+    private readonly health;
+    private readonly logger;
+    private readonly healthChecks;
+    constructor(health: HealthCheckService, logger: ObservabilityLoggerInterface, healthChecks: HealthChecks);
+    getHealth(): Promise<void>;
+}
+export declare const createHealthCli: (options: HealthCliOptionsInterface) => Type<HealthCliCommands>;

package/dist/esm/health/cli/health-cli.js

@@ -0,0 +1,52 @@
+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, ServiceUnavailableException } from '@nestjs/common';
+import { HealthCheckService } from '@nestjs/terminus';
+import { Command, Console } from 'nestjs-console';
+import { OBSERVABILITY_LOGGER } from '../../logging/constants.js';
+import { withClassDecorator } from '../../shared/with-class-decorator.js';
+import { HealthChecks } from '../health-checks.js';
+let HealthCliCommands = class HealthCliCommands {
+    health;
+    logger;
+    healthChecks;
+    constructor(health, logger, healthChecks) {
+        this.health = health;
+        this.logger = logger;
+        this.healthChecks = healthChecks;
+    }
+    async getHealth() {
+        try {
+            const healthResult = await this.health.check(this.healthChecks.build());
+            this.logger.info({ healthResult }, healthResult.status);
+        }
+        catch (error) {
+            const healthResult = error instanceof ServiceUnavailableException ? error.getResponse() : 'unknown';
+            this.logger.error({ healthResult }, 'error');
+        }
+    }
+};
+__decorate([
+    Command({ command: 'health' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthCliCommands.prototype, "getHealth", null);
+HealthCliCommands = __decorate([
+    __param(0, Inject(HealthCheckService)),
+    __param(1, Inject(OBSERVABILITY_LOGGER)),
+    __param(2, Inject(HealthChecks)),
+    __metadata("design:paramtypes", [HealthCheckService, Object, HealthChecks])
+], HealthCliCommands);
+export { HealthCliCommands };
+export const createHealthCli = (options) => withClassDecorator(HealthCliCommands, Console({ command: options.command }));

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

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

package/dist/esm/health/cli/health-cli.module.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;
+};
+import { Module } from '@nestjs/common';
+import { createHealthCli } from './health-cli.js';
+let HealthCliModule = class HealthCliModule {
+    static forRoot(options) {
+        return {
+            module: this,
+            providers: [createHealthCli(options)],
+        };
+    }
+};
+HealthCliModule = __decorate([
+    Module({})
+], HealthCliModule);
+export { HealthCliModule };

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

@@ -0,0 +1,3 @@
+export * from './health-cli.js';
+export * from './health-cli-options.interface.js';
+export * from './health-cli.module.js';

package/dist/esm/health/cli/index.js

@@ -0,0 +1,3 @@
+export * from './health-cli.js';
+export * from './health-cli-options.interface.js';
+export * from './health-cli.module.js';

package/dist/esm/health/graphql/health-check.type.d.ts

@@ -0,0 +1,3 @@
+export declare class HealthCheckType {
+    status: string;
+}

package/dist/esm/health/graphql/health-check.type.js

@@ -0,0 +1,21 @@
+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 { Field, ObjectType } from '@nestjs/graphql';
+let HealthCheckType = class HealthCheckType {
+    status;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], HealthCheckType.prototype, "status", void 0);
+HealthCheckType = __decorate([
+    ObjectType('HealthCheck')
+], HealthCheckType);
+export { HealthCheckType };

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

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

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

@@ -0,0 +1,23 @@
+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 { applyDecorators, Module } from '@nestjs/common';
+import { Resolver } from '@nestjs/graphql';
+import { withClassDecorator } from '../../shared/with-class-decorator.js';
+import { HealthResolver } from './health.resolver.js';
+let HealthGraphqlModule = class HealthGraphqlModule {
+    static forRoot(options = {}) {
+        const consumerDecorators = options.publicRoute === undefined ? [] : [options.publicRoute];
+        return {
+            module: this,
+            providers: [withClassDecorator(HealthResolver, applyDecorators(Resolver(), ...consumerDecorators))],
+        };
+    }
+};
+HealthGraphqlModule = __decorate([
+    Module({})
+], HealthGraphqlModule);
+export { HealthGraphqlModule };

package/dist/esm/health/graphql/health.resolver.d.ts

@@ -0,0 +1,11 @@
+import { HealthCheckService } from '@nestjs/terminus';
+import type { ObservabilityLoggerInterface } from '../../logging/observability-logger.interface.js';
+import { HealthChecks } from '../health-checks.js';
+import { HealthCheckType } from './health-check.type.js';
+export declare class HealthResolver {
+    private readonly healthCheck;
+    private readonly logger;
+    private readonly healthChecks;
+    constructor(healthCheck: HealthCheckService, logger: ObservabilityLoggerInterface, healthChecks: HealthChecks);
+    health(): Promise<HealthCheckType>;
+}