@application-kit/observability 0.1.0 → 0.3.0

package/dist/esm/health/graphql/health.resolver.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 } from '@nestjs/common';
+import { Query, Resolver } from '@nestjs/graphql';
+import { HealthCheckService } from '@nestjs/terminus';
+import { OBSERVABILITY_LOGGER } from '../../logging/constants.js';
+import { HealthChecks } from '../health-checks.js';
+import { HealthCheckType } from './health-check.type.js';
+let HealthResolver = class HealthResolver {
+    healthCheck;
+    logger;
+    healthChecks;
+    constructor(healthCheck, logger, healthChecks) {
+        this.healthCheck = healthCheck;
+        this.logger = logger;
+        this.healthChecks = healthChecks;
+    }
+    async health() {
+        try {
+            const health = await this.healthCheck.check(this.healthChecks.build());
+            return { status: health.status };
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'GraphQL health check failed');
+            return { status: 'error' };
+        }
+    }
+};
+__decorate([
+    Query(() => HealthCheckType),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthResolver.prototype, "health", null);
+HealthResolver = __decorate([
+    Resolver({ isAbstract: true }),
+    __param(0, Inject(HealthCheckService)),
+    __param(1, Inject(OBSERVABILITY_LOGGER)),
+    __param(2, Inject(HealthChecks)),
+    __metadata("design:paramtypes", [HealthCheckService, Object, HealthChecks])
+], HealthResolver);
+export { HealthResolver };

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

@@ -0,0 +1,3 @@
+export * from './health-check.type.js';
+export * from './health-graphql.module.js';
+export * from './health.resolver.js';

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

@@ -0,0 +1,3 @@
+export * from './health-check.type.js';
+export * from './health-graphql.module.js';
+export * from './health.resolver.js';

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

@@ -0,0 +1,10 @@
+import { DiskHealthIndicator, HealthIndicatorFunction, MemoryHealthIndicator, TypeOrmHealthIndicator } from '@nestjs/terminus';
+import { HealthConfig } from './health.config.js';
+export declare class HealthChecks {
+    private readonly database;
+    private readonly memory;
+    private readonly disk;
+    private readonly config;
+    constructor(database: TypeOrmHealthIndicator, memory: MemoryHealthIndicator, disk: DiskHealthIndicator, config: HealthConfig);
+    build(): HealthIndicatorFunction[];
+}

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

@@ -0,0 +1,50 @@
+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 { DiskHealthIndicator, MemoryHealthIndicator, TypeOrmHealthIndicator, } from '@nestjs/terminus';
+import { HealthConfig } from './health.config.js';
+let HealthChecks = class HealthChecks {
+    database;
+    memory;
+    disk;
+    config;
+    constructor(database, memory, disk, config) {
+        this.database = database;
+        this.memory = memory;
+        this.disk = disk;
+        this.config = config;
+    }
+    build() {
+        return [
+            async () => this.database.pingCheck('typeorm'),
+            async () => this.memory.checkHeap('memory_heap', this.config.memoryHeapBytes),
+            async () => this.memory.checkRSS('memory_rss', this.config.memoryRssBytes),
+            async () => this.disk.checkStorage('disk', {
+                path: '/',
+                thresholdPercent: this.config.diskThresholdPercent,
+            }),
+        ];
+    }
+};
+HealthChecks = __decorate([
+    Injectable(),
+    __param(0, Inject(TypeOrmHealthIndicator)),
+    __param(1, Inject(MemoryHealthIndicator)),
+    __param(2, Inject(DiskHealthIndicator)),
+    __param(3, Inject(HealthConfig)),
+    __metadata("design:paramtypes", [TypeOrmHealthIndicator,
+        MemoryHealthIndicator,
+        DiskHealthIndicator,
+        HealthConfig])
+], HealthChecks);
+export { HealthChecks };

package/dist/esm/health/health-http.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 HealthHttpModule {
+    static forRoot(options?: HealthCarrierOptionsInterface): DynamicModule;
+}

package/dist/esm/health/health-http.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 { Module } from '@nestjs/common';
+import { withClassDecorator } from '../shared/with-class-decorator.js';
+import { HealthController } from './health.controller.js';
+import { MigrationsHealthIndicator } from './migrations.health-indicator.js';
+let HealthHttpModule = class HealthHttpModule {
+    static forRoot(options = {}) {
+        return {
+            controllers: [withClassDecorator(HealthController, options.publicRoute)],
+            module: this,
+            providers: [MigrationsHealthIndicator],
+        };
+    }
+};
+HealthHttpModule = __decorate([
+    Module({})
+], HealthHttpModule);
+export { HealthHttpModule };

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

@@ -0,0 +1,9 @@
+import type { ModuleMetadata } from '@nestjs/common';
+import type { TerminusModuleOptions } from '@nestjs/terminus';
+export interface HealthCarrierOptionsInterface {
+    readonly publicRoute?: ClassDecorator;
+}
+export interface HealthModuleOptionsInterface {
+    readonly imports?: ModuleMetadata['imports'];
+    readonly terminus?: TerminusModuleOptions;
+}

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

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

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

@@ -0,0 +1,8 @@
+import { HealthEnvironment } from './health.environment.js';
+export declare class HealthConfig {
+    private readonly environment;
+    get diskThresholdPercent(): number;
+    get memoryHeapBytes(): number;
+    get memoryRssBytes(): number;
+    constructor(environment: HealthEnvironment);
+}

package/dist/esm/health/health.config.js

@@ -0,0 +1,36 @@
+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 { HealthEnvironment } from './health.environment.js';
+const BYTES_IN_MEGABYTE = 1024 * 1024;
+let HealthConfig = class HealthConfig {
+    environment;
+    get diskThresholdPercent() {
+        return this.environment.HEALTH_DISK_THRESHOLD_PERCENT;
+    }
+    get memoryHeapBytes() {
+        return this.environment.HEALTH_MEMORY_HEAP_MB * BYTES_IN_MEGABYTE;
+    }
+    get memoryRssBytes() {
+        return this.environment.HEALTH_MEMORY_RSS_MB * BYTES_IN_MEGABYTE;
+    }
+    constructor(environment) {
+        this.environment = environment;
+    }
+};
+HealthConfig = __decorate([
+    Injectable(),
+    __param(0, Inject(HealthEnvironment)),
+    __metadata("design:paramtypes", [HealthEnvironment])
+], HealthConfig);
+export { HealthConfig };

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

@@ -0,0 +1,14 @@
+import type { HealthCheckResult } from '@nestjs/terminus';
+import { HealthCheckService, TypeOrmHealthIndicator } from '@nestjs/terminus';
+import { HealthChecks } from './health-checks.js';
+import { MigrationsHealthIndicator } from './migrations.health-indicator.js';
+export declare class HealthController {
+    private readonly health;
+    private readonly database;
+    private readonly migrations;
+    private readonly healthChecks;
+    constructor(health: HealthCheckService, database: TypeOrmHealthIndicator, migrations: MigrationsHealthIndicator, healthChecks: HealthChecks);
+    check(): Promise<HealthCheckResult>;
+    live(): Promise<HealthCheckResult>;
+    ready(): Promise<HealthCheckResult>;
+}

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/http/client-ip-options.interface.d.ts

@@ -0,0 +1,3 @@
+export interface ClientIpOptionsInterface {
+    readonly trustedHeaders?: readonly string[];
+}

package/dist/esm/http/client-ip-options.interface.js

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

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

@@ -0,0 +1,2 @@
+export * from './client-ip-options.interface.js';
+export * from './resolve-client-ip.js';

package/dist/esm/http/index.js

@@ -0,0 +1,2 @@
+export * from './client-ip-options.interface.js';
+export * from './resolve-client-ip.js';

package/dist/esm/http/resolve-client-ip.d.ts

@@ -0,0 +1,14 @@
+import type { ClientIpOptionsInterface } from './client-ip-options.interface.js';
+export interface ClientIpSourceInterface {
+    headers?: Record<string, string | string[] | undefined> | undefined;
+    ip?: string | undefined;
+    raw?: {
+        socket?: SocketLikeInterface | undefined;
+    } | undefined;
+    socket?: SocketLikeInterface | undefined;
+}
+interface SocketLikeInterface {
+    remoteAddress?: string | undefined;
+}
+export declare const resolveClientIp: (request: ClientIpSourceInterface, options?: ClientIpOptionsInterface) => string;
+export {};

package/dist/esm/http/resolve-client-ip.js

@@ -0,0 +1,18 @@
+const firstHeaderValue = (value) => {
+    const single = Array.isArray(value) ? value[0] : value;
+    return (single ?? '').trim();
+};
+const trustedHeaderIp = (request, trustedHeaders) => {
+    const values = trustedHeaders?.map((header) => firstHeaderValue(request.headers?.[header]));
+    return values?.find((value) => value !== '') ?? '';
+};
+const rawSocketIp = (request) => request.raw?.socket?.remoteAddress ?? '';
+const socketIp = (request) => request.socket?.remoteAddress ?? rawSocketIp(request);
+const fallbackIp = (request) => {
+    const proxyAwareIp = (request.ip ?? '').trim();
+    return proxyAwareIp === '' ? socketIp(request) : proxyAwareIp;
+};
+export const resolveClientIp = (request, options = {}) => {
+    const headerIp = trustedHeaderIp(request, options.trustedHeaders);
+    return headerIp === '' ? fallbackIp(request) : headerIp;
+};

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

@@ -0,0 +1 @@
+export declare const OBSERVABILITY_LOGGER: unique symbol;

package/dist/esm/logging/constants.js

@@ -0,0 +1 @@
+export const OBSERVABILITY_LOGGER = Symbol('OBSERVABILITY_LOGGER');

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.d.ts

@@ -0,0 +1,4 @@
+export interface ObservabilityLoggerInterface {
+    error(payload: object, message: string): void;
+    info(payload: object, message: string): void;
+}

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;
+}