@nlite/logger-hapi 1.0.0

package/README.md

@@ -0,0 +1,48 @@
+# NLite Logger Hapi SDK
+
+Hapi plugin for integrating NLite Logger into your Hapi application.
+
+## Features
+
+- Seamless integration with Hapi.js
+- Automatic request logging
+- Structured log output
+- Real-time log streaming support
+
+## Installation
+
+```bash
+npm install @nlite/logger-hapi
+```
+
+## Requirements
+
+- @hapi/hapi >= 20.0.0
+
+## Usage
+
+```typescript
+import Hapi from '@hapi/hapi';
+import NliteLogger from '@nlite/logger-hapi';
+
+const server = Hapi.server({
+  port: 3000,
+});
+
+await server.register(NliteLogger);
+```
+
+## Scripts
+
+| Script | Description |
+|--------|-------------|
+| `build` | Compile TypeScript |
+| `dev` | Watch mode for development |
+| `test` | Run tests with Vitest |
+| `test:watch` | Run tests in watch mode |
+| `lint` | Lint source files |
+| `typecheck` | Type check with TypeScript |
+
+## Author
+
+Debanjan Dasgupta

package/dist/index.cjs

@@ -0,0 +1,284 @@
+// @ts-nocheck
+// Hapi.js Middleware for NLite Logger
+import { createLogger, FetchTransport } from '@nlite/logger-core';
+export function createHapiMiddleware(options) {
+    const { loggerConfig, captureRequest = true, captureResponse = true, captureError = true, ignorePaths = ['/health', '/ready', '/metrics', '/favicon.ico'], customTags = {}, getUserId, getSessionId, getTraceId, } = options;
+    // Create logger instance
+    const transport = new FetchTransport(loggerConfig.endpoint || 'http://localhost:3000', loggerConfig.apiKey, loggerConfig.headers, loggerConfig.timeout);
+    const logger = createLogger(loggerConfig, transport);
+    // Add custom tags
+    logger.setTags(customTags);
+    return {
+        name: 'nlite-logger',
+        version: '1.0.0',
+        register: async (server) => {
+            // Store logger on server for access in routes
+            server.decorate('request', 'nLiteLogger', logger);
+            // Request logging
+            server.ext('onRequest', (request, h) => {
+                // Skip ignored paths
+                if (ignorePaths.some(path => request.path.startsWith(path))) {
+                    return h.continue;
+                }
+                const startTime = Date.now();
+                const traceId = getTraceId?.(request) || request.headers['x-trace-id'] || request.headers['trace-id'] || `trace-${startTime}-${Math.random().toString(36).substr(2, 9)}`;
+                const spanId = `span-${startTime}-${Math.random().toString(36).substr(2, 9)}`;
+                // Store context
+                request.nLiteLogContext = { startTime, traceId, spanId };
+                // Capture request
+                if (captureRequest) {
+                    const logRequest = {
+                        method: request.method.toUpperCase(),
+                        url: `${request.info.host}${request.path}`,
+                        path: request.path,
+                        query: request.query,
+                        headers: sanitizeHeaders(request.headers),
+                        body: request.payload ? clonePayload(request.payload) : undefined,
+                        ip: request.info.remoteAddress,
+                        userAgent: request.headers['user-agent'] || '',
+                    };
+                    logger.addBreadcrumb({
+                        type: 'http',
+                        category: 'request',
+                        message: `${request.method.toUpperCase()} ${request.path}`,
+                        data: { method: request.method, path: request.path },
+                        level: 'info',
+                    });
+                    // Store for response logging
+                    request._nliteRequest = logRequest;
+                }
+                // Set user context if available
+                const userId = getUserId?.(request);
+                if (userId) {
+                    logger.setUser(userId);
+                }
+                const sessionId = getSessionId?.(request);
+                if (sessionId) {
+                    logger.setTags({ sessionId });
+                }
+                return h.continue;
+            });
+            // Response logging
+            if (captureResponse) {
+                server.ext('onPreResponse', (request, h) => {
+                    const response = request.response;
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    if (context && logRequest) {
+                        const durationMs = Date.now() - context.startTime;
+                        const isBoom = response.isBoom;
+                        const logResponse = {
+                            statusCode: isBoom ? response.output.statusCode : response.statusCode || 200,
+                            statusText: isBoom ? response.output.payload.error : 'OK',
+                            headers: response.headers || {},
+                            body: isBoom ? response.output.payload : response.source,
+                            durationMs,
+                        };
+                        const level = logResponse.statusCode >= 500 ? 'error' : logResponse.statusCode >= 400 ? 'warn' : 'info';
+                        logger.log(level, `${request.method.toUpperCase()} ${request.path} ${logResponse.statusCode}`, {
+                            request: logRequest,
+                            response: logResponse,
+                            durationMs,
+                            traceId: context.traceId,
+                            spanId: context.spanId,
+                            userId: getUserId?.(request),
+                            sessionId: getSessionId?.(request),
+                        });
+                    }
+                    return h.continue;
+                });
+            }
+            // Error logging
+            if (captureError) {
+                // Capture request errors using 'request' event with error tags
+                server.events.on('request', (request, event, tags) => {
+                    if (tags.error) {
+                        const context = request.nLiteLogContext;
+                        const logRequest = request._nliteRequest;
+                        const errorMessage = typeof event === 'string' ? event : 'Request error';
+                        logger.error(errorMessage, new Error(errorMessage), {
+                            request: logRequest,
+                            traceId: context?.traceId,
+                            spanId: context?.spanId,
+                            userId: getUserId?.(request),
+                            sessionId: getSessionId?.(request),
+                            tags: ['hapi', 'request-error'],
+                        });
+                    }
+                });
+                // Capture internal server errors (5xx responses)
+                server.ext('onPreResponse', (request, h) => {
+                    const response = request.response;
+                    if (response.isBoom && response.output.statusCode >= 500) {
+                        const context = request.nLiteLogContext;
+                        const logRequest = request._nliteRequest;
+                        logger.error(response.message, new Error(response.message), {
+                            request: logRequest,
+                            traceId: context?.traceId,
+                            spanId: context?.spanId,
+                            userId: getUserId?.(request),
+                            sessionId: getSessionId?.(request),
+                            tags: ['hapi', 'server-error'],
+                            errorCode: response.output.payload.error,
+                        });
+                    }
+                    return h.continue;
+                });
+            }
+            // Additional event handlers for comprehensive logging
+            // Log response for all requests (if captureResponse is enabled)
+            if (captureResponse) {
+                server.ext('onPreResponse', (request, h) => {
+                    const response = request.response;
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    if (context && logRequest) {
+                        const durationMs = Date.now() - context.startTime;
+                        const isBoom = response.isBoom;
+                        const logResponse = {
+                            statusCode: isBoom ? response.output.statusCode : response.statusCode || 200,
+                            statusText: isBoom ? response.output.payload.error : 'OK',
+                            headers: response.headers || {},
+                            body: isBoom ? response.output.payload : response.source,
+                            durationMs,
+                        };
+                        const level = logResponse.statusCode >= 500 ? 'error' : logResponse.statusCode >= 400 ? 'warn' : 'info';
+                        logger.log(level, `${request.method.toUpperCase()} ${request.path} ${logResponse.statusCode}`, {
+                            request: logRequest,
+                            response: logResponse,
+                            durationMs,
+                            traceId: context.traceId,
+                            spanId: context.spanId,
+                            userId: getUserId?.(request),
+                            sessionId: getSessionId?.(request),
+                        });
+                    }
+                    return h.continue;
+                });
+            }
+            // Log route not found (404)
+            server.ext('onPreResponse', (request, h) => {
+                const response = request.response;
+                if (response.isBoom && response.output.statusCode === 404) {
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    logger.warn(`Route not found: ${request.method.toUpperCase()} ${request.path}`, {
+                        request: logRequest,
+                        traceId: context?.traceId,
+                        spanId: context?.spanId,
+                        tags: ['hapi', 'route-not-found'],
+                    });
+                }
+                return h.continue;
+            });
+            // Log validation errors (400)
+            server.ext('onPreResponse', (request, h) => {
+                const response = request.response;
+                if (response.isBoom && response.output.statusCode === 400) {
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    logger.warn(`Validation error: ${request.method.toUpperCase()} ${request.path}`, {
+                        request: logRequest,
+                        traceId: context?.traceId,
+                        spanId: context?.spanId,
+                        tags: ['hapi', 'validation-error'],
+                        errorDetails: response.output.payload,
+                    });
+                }
+                return h.continue;
+            });
+            // Log authentication errors (401, 403)
+            server.ext('onPreResponse', (request, h) => {
+                const response = request.response;
+                if (response.isBoom && (response.output.statusCode === 401 || response.output.statusCode === 403)) {
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    logger.warn(`Auth error ${response.output.statusCode}: ${request.method.toUpperCase()} ${request.path}`, {
+                        request: logRequest,
+                        traceId: context?.traceId,
+                        spanId: context?.spanId,
+                        tags: ['hapi', 'auth-error'],
+                        errorCode: response.output.payload.error,
+                    });
+                }
+                return h.continue;
+            });
+            // Log request payload size for large payloads
+            server.ext('onRequest', (request, h) => {
+                if (request.payload && typeof request.payload === 'object') {
+                    const payloadSize = JSON.stringify(request.payload).length;
+                    if (payloadSize > 10000) { // Log if payload > 10KB
+                        logger.debug('Large request payload', {
+                            path: request.path,
+                            method: request.method,
+                            payloadSize,
+                            tags: ['hapi', 'large-payload'],
+                        });
+                    }
+                }
+                return h.continue;
+            });
+            // Graceful shutdown
+            server.events.on('stop', async () => {
+                await logger.destroy();
+            });
+        },
+    };
+}
+// Helper to access logger in route handlers
+export function getLogger(request) {
+    return request.nLiteLogger;
+}
+// Plugin options validation
+export const hapiMiddlewareOptionsSchema = {
+    loggerConfig: { required: true },
+    captureRequest: { type: 'boolean', default: true },
+    captureResponse: { type: 'boolean', default: true },
+    captureError: { type: 'boolean', default: true },
+    ignorePaths: { type: 'array', items: 'string', default: ['/health', '/ready', '/metrics'] },
+    customTags: { type: 'object', default: {} },
+    getUserId: { type: 'function' },
+    getSessionId: { type: 'function' },
+    getTraceId: { type: 'function' },
+};
+// Utility functions
+function sanitizeHeaders(headers) {
+    const sanitized = {};
+    const sensitiveHeaders = ['authorization', 'cookie', 'x-api-key', 'x-auth-token', 'proxy-authorization'];
+    for (const [key, value] of Object.entries(headers)) {
+        if (sensitiveHeaders.includes(key.toLowerCase())) {
+            sanitized[key] = '[REDACTED]';
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}
+function clonePayload(payload) {
+    try {
+        if (typeof payload === 'object' && payload !== null) {
+            return JSON.parse(JSON.stringify(payload));
+        }
+        return payload;
+    }
+    catch {
+        return '[UNCLONEABLE]';
+    }
+}
+// Default configuration helper
+export function createDefaultHapiConfig(apiKey, appName, options = {}) {
+    return {
+        loggerConfig: {
+            apiKey,
+            appName,
+            platform: 'backend',
+            environment: process.env.NODE_ENV || 'development',
+            appVersion: process.env.npm_package_version || '1.0.0',
+            endpoint: process.env.NLITE_ENDPOINT || 'http://localhost:3000',
+            autoCapture: true,
+            ...options.loggerConfig,
+        },
+        ...options,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+import { Server, Request } from '@hapi/hapi';
+import { type LoggerSdk, type SdkConfig } from '@nlite/logger-core';
+export interface HapiMiddlewareOptions {
+    /** Logger SDK configuration */
+    loggerConfig: SdkConfig;
+    /** Capture request details (default: true) */
+    captureRequest?: boolean;
+    /** Capture response details (default: true) */
+    captureResponse?: boolean;
+    /** Capture errors (default: true) */
+    captureError?: boolean;
+    /** Paths to ignore (default: ['/health', '/ready', '/metrics']) */
+    ignorePaths?: string[];
+    /** Custom tags to add to all logs */
+    customTags?: Record<string, string>;
+    /** Function to extract user ID from request */
+    getUserId?: (request: Request) => string | undefined;
+    /** Function to extract session ID from request */
+    getSessionId?: (request: Request) => string | undefined;
+    /** Function to extract trace ID from request */
+    getTraceId?: (request: Request) => string | undefined;
+}
+declare module '@hapi/hapi' {
+    interface Request {
+        nLiteLogger?: LoggerSdk;
+        nLiteLogContext?: {
+            startTime: number;
+            traceId: string;
+            spanId: string;
+        };
+    }
+}
+export declare function createHapiMiddleware(options: HapiMiddlewareOptions): {
+    name: string;
+    version: string;
+    register: (server: Server) => Promise<void>;
+};
+export declare function getLogger(request: Request): LoggerSdk;
+export declare const hapiMiddlewareOptionsSchema: {
+    loggerConfig: {
+        required: boolean;
+    };
+    captureRequest: {
+        type: string;
+        default: boolean;
+    };
+    captureResponse: {
+        type: string;
+        default: boolean;
+    };
+    captureError: {
+        type: string;
+        default: boolean;
+    };
+    ignorePaths: {
+        type: string;
+        items: string;
+        default: string[];
+    };
+    customTags: {
+        type: string;
+        default: {};
+    };
+    getUserId: {
+        type: string;
+    };
+    getSessionId: {
+        type: string;
+    };
+    getTraceId: {
+        type: string;
+    };
+};
+export declare function createDefaultHapiConfig(apiKey: string, appName: string, options?: Partial<HapiMiddlewareOptions>): HapiMiddlewareOptions;
+export type { LoggerSdk, SdkConfig, LogLevel, LogContext, LogRequest, LogResponse } from '@nlite/logger-core';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,OAAO,EAA8B,MAAM,YAAY,CAAC;AACzE,OAAO,EAAgC,KAAK,SAAS,EAAE,KAAK,SAAS,EAAqE,MAAM,oBAAoB,CAAC;AAErK,MAAM,WAAW,qBAAqB;IACpC,+BAA+B;IAC/B,YAAY,EAAE,SAAS,CAAC;IACxB,8CAA8C;IAC9C,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,+CAA+C;IAC/C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qCAAqC;IACrC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,qCAAqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,+CAA+C;IAC/C,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;IACrD,kDAAkD;IAClD,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;IACxD,gDAAgD;IAChD,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;CACvD;AAED,OAAO,QAAQ,YAAY,CAAC;IAC1B,UAAU,OAAO;QACf,WAAW,CAAC,EAAE,SAAS,CAAC;QACxB,eAAe,CAAC,EAAE;YAChB,SAAS,EAAE,MAAM,CAAC;YAClB,OAAO,EAAE,MAAM,CAAC;YAChB,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;KACH;CACF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB;;;uBAuBtC,MAAM;EAwPlC;AAGD,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAErD;AAGD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUvC,CAAC;AA6BF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,OAAO,CAAC,qBAAqB,CAAM,GAC3C,qBAAqB,CAcvB;AAGD,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,284 @@
+// @ts-nocheck
+// Hapi.js Middleware for NLite Logger
+import { createLogger, FetchTransport } from '@nlite/logger-core';
+export function createHapiMiddleware(options) {
+    const { loggerConfig, captureRequest = true, captureResponse = true, captureError = true, ignorePaths = ['/health', '/ready', '/metrics', '/favicon.ico'], customTags = {}, getUserId, getSessionId, getTraceId, } = options;
+    // Create logger instance
+    const transport = new FetchTransport(loggerConfig.endpoint || 'http://localhost:3000', loggerConfig.apiKey, loggerConfig.headers, loggerConfig.timeout);
+    const logger = createLogger(loggerConfig, transport);
+    // Add custom tags
+    logger.setTags(customTags);
+    return {
+        name: 'nlite-logger',
+        version: '1.0.0',
+        register: async (server) => {
+            // Store logger on server for access in routes
+            server.decorate('request', 'nLiteLogger', logger);
+            // Request logging
+            server.ext('onRequest', (request, h) => {
+                // Skip ignored paths
+                if (ignorePaths.some(path => request.path.startsWith(path))) {
+                    return h.continue;
+                }
+                const startTime = Date.now();
+                const traceId = getTraceId?.(request) || request.headers['x-trace-id'] || request.headers['trace-id'] || `trace-${startTime}-${Math.random().toString(36).substr(2, 9)}`;
+                const spanId = `span-${startTime}-${Math.random().toString(36).substr(2, 9)}`;
+                // Store context
+                request.nLiteLogContext = { startTime, traceId, spanId };
+                // Capture request
+                if (captureRequest) {
+                    const logRequest = {
+                        method: request.method.toUpperCase(),
+                        url: `${request.info.host}${request.path}`,
+                        path: request.path,
+                        query: request.query,
+                        headers: sanitizeHeaders(request.headers),
+                        body: request.payload ? clonePayload(request.payload) : undefined,
+                        ip: request.info.remoteAddress,
+                        userAgent: request.headers['user-agent'] || '',
+                    };
+                    logger.addBreadcrumb({
+                        type: 'http',
+                        category: 'request',
+                        message: `${request.method.toUpperCase()} ${request.path}`,
+                        data: { method: request.method, path: request.path },
+                        level: 'info',
+                    });
+                    // Store for response logging
+                    request._nliteRequest = logRequest;
+                }
+                // Set user context if available
+                const userId = getUserId?.(request);
+                if (userId) {
+                    logger.setUser(userId);
+                }
+                const sessionId = getSessionId?.(request);
+                if (sessionId) {
+                    logger.setTags({ sessionId });
+                }
+                return h.continue;
+            });
+            // Response logging
+            if (captureResponse) {
+                server.ext('onPreResponse', (request, h) => {
+                    const response = request.response;
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    if (context && logRequest) {
+                        const durationMs = Date.now() - context.startTime;
+                        const isBoom = response.isBoom;
+                        const logResponse = {
+                            statusCode: isBoom ? response.output.statusCode : response.statusCode || 200,
+                            statusText: isBoom ? response.output.payload.error : 'OK',
+                            headers: response.headers || {},
+                            body: isBoom ? response.output.payload : response.source,
+                            durationMs,
+                        };
+                        const level = logResponse.statusCode >= 500 ? 'error' : logResponse.statusCode >= 400 ? 'warn' : 'info';
+                        logger.log(level, `${request.method.toUpperCase()} ${request.path} ${logResponse.statusCode}`, {
+                            request: logRequest,
+                            response: logResponse,
+                            durationMs,
+                            traceId: context.traceId,
+                            spanId: context.spanId,
+                            userId: getUserId?.(request),
+                            sessionId: getSessionId?.(request),
+                        });
+                    }
+                    return h.continue;
+                });
+            }
+            // Error logging
+            if (captureError) {
+                // Capture request errors using 'request' event with error tags
+                server.events.on('request', (request, event, tags) => {
+                    if (tags.error) {
+                        const context = request.nLiteLogContext;
+                        const logRequest = request._nliteRequest;
+                        const errorMessage = typeof event === 'string' ? event : 'Request error';
+                        logger.error(errorMessage, new Error(errorMessage), {
+                            request: logRequest,
+                            traceId: context?.traceId,
+                            spanId: context?.spanId,
+                            userId: getUserId?.(request),
+                            sessionId: getSessionId?.(request),
+                            tags: ['hapi', 'request-error'],
+                        });
+                    }
+                });
+                // Capture internal server errors (5xx responses)
+                server.ext('onPreResponse', (request, h) => {
+                    const response = request.response;
+                    if (response.isBoom && response.output.statusCode >= 500) {
+                        const context = request.nLiteLogContext;
+                        const logRequest = request._nliteRequest;
+                        logger.error(response.message, new Error(response.message), {
+                            request: logRequest,
+                            traceId: context?.traceId,
+                            spanId: context?.spanId,
+                            userId: getUserId?.(request),
+                            sessionId: getSessionId?.(request),
+                            tags: ['hapi', 'server-error'],
+                            errorCode: response.output.payload.error,
+                        });
+                    }
+                    return h.continue;
+                });
+            }
+            // Additional event handlers for comprehensive logging
+            // Log response for all requests (if captureResponse is enabled)
+            if (captureResponse) {
+                server.ext('onPreResponse', (request, h) => {
+                    const response = request.response;
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    if (context && logRequest) {
+                        const durationMs = Date.now() - context.startTime;
+                        const isBoom = response.isBoom;
+                        const logResponse = {
+                            statusCode: isBoom ? response.output.statusCode : response.statusCode || 200,
+                            statusText: isBoom ? response.output.payload.error : 'OK',
+                            headers: response.headers || {},
+                            body: isBoom ? response.output.payload : response.source,
+                            durationMs,
+                        };
+                        const level = logResponse.statusCode >= 500 ? 'error' : logResponse.statusCode >= 400 ? 'warn' : 'info';
+                        logger.log(level, `${request.method.toUpperCase()} ${request.path} ${logResponse.statusCode}`, {
+                            request: logRequest,
+                            response: logResponse,
+                            durationMs,
+                            traceId: context.traceId,
+                            spanId: context.spanId,
+                            userId: getUserId?.(request),
+                            sessionId: getSessionId?.(request),
+                        });
+                    }
+                    return h.continue;
+                });
+            }
+            // Log route not found (404)
+            server.ext('onPreResponse', (request, h) => {
+                const response = request.response;
+                if (response.isBoom && response.output.statusCode === 404) {
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    logger.warn(`Route not found: ${request.method.toUpperCase()} ${request.path}`, {
+                        request: logRequest,
+                        traceId: context?.traceId,
+                        spanId: context?.spanId,
+                        tags: ['hapi', 'route-not-found'],
+                    });
+                }
+                return h.continue;
+            });
+            // Log validation errors (400)
+            server.ext('onPreResponse', (request, h) => {
+                const response = request.response;
+                if (response.isBoom && response.output.statusCode === 400) {
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    logger.warn(`Validation error: ${request.method.toUpperCase()} ${request.path}`, {
+                        request: logRequest,
+                        traceId: context?.traceId,
+                        spanId: context?.spanId,
+                        tags: ['hapi', 'validation-error'],
+                        errorDetails: response.output.payload,
+                    });
+                }
+                return h.continue;
+            });
+            // Log authentication errors (401, 403)
+            server.ext('onPreResponse', (request, h) => {
+                const response = request.response;
+                if (response.isBoom && (response.output.statusCode === 401 || response.output.statusCode === 403)) {
+                    const context = request.nLiteLogContext;
+                    const logRequest = request._nliteRequest;
+                    logger.warn(`Auth error ${response.output.statusCode}: ${request.method.toUpperCase()} ${request.path}`, {
+                        request: logRequest,
+                        traceId: context?.traceId,
+                        spanId: context?.spanId,
+                        tags: ['hapi', 'auth-error'],
+                        errorCode: response.output.payload.error,
+                    });
+                }
+                return h.continue;
+            });
+            // Log request payload size for large payloads
+            server.ext('onRequest', (request, h) => {
+                if (request.payload && typeof request.payload === 'object') {
+                    const payloadSize = JSON.stringify(request.payload).length;
+                    if (payloadSize > 10000) { // Log if payload > 10KB
+                        logger.debug('Large request payload', {
+                            path: request.path,
+                            method: request.method,
+                            payloadSize,
+                            tags: ['hapi', 'large-payload'],
+                        });
+                    }
+                }
+                return h.continue;
+            });
+            // Graceful shutdown
+            server.events.on('stop', async () => {
+                await logger.destroy();
+            });
+        },
+    };
+}
+// Helper to access logger in route handlers
+export function getLogger(request) {
+    return request.nLiteLogger;
+}
+// Plugin options validation
+export const hapiMiddlewareOptionsSchema = {
+    loggerConfig: { required: true },
+    captureRequest: { type: 'boolean', default: true },
+    captureResponse: { type: 'boolean', default: true },
+    captureError: { type: 'boolean', default: true },
+    ignorePaths: { type: 'array', items: 'string', default: ['/health', '/ready', '/metrics'] },
+    customTags: { type: 'object', default: {} },
+    getUserId: { type: 'function' },
+    getSessionId: { type: 'function' },
+    getTraceId: { type: 'function' },
+};
+// Utility functions
+function sanitizeHeaders(headers) {
+    const sanitized = {};
+    const sensitiveHeaders = ['authorization', 'cookie', 'x-api-key', 'x-auth-token', 'proxy-authorization'];
+    for (const [key, value] of Object.entries(headers)) {
+        if (sensitiveHeaders.includes(key.toLowerCase())) {
+            sanitized[key] = '[REDACTED]';
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}
+function clonePayload(payload) {
+    try {
+        if (typeof payload === 'object' && payload !== null) {
+            return JSON.parse(JSON.stringify(payload));
+        }
+        return payload;
+    }
+    catch {
+        return '[UNCLONEABLE]';
+    }
+}
+// Default configuration helper
+export function createDefaultHapiConfig(apiKey, appName, options = {}) {
+    return {
+        loggerConfig: {
+            apiKey,
+            appName,
+            platform: 'backend',
+            environment: process.env.NODE_ENV || 'development',
+            appVersion: process.env.npm_package_version || '1.0.0',
+            endpoint: process.env.NLITE_ENDPOINT || 'http://localhost:3000',
+            autoCapture: true,
+            ...options.loggerConfig,
+        },
+        ...options,
+    };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@nlite/logger-hapi",
+  "version": "1.0.0",
+  "type": "module",
+  "keywords": [
+    "logging",
+    "logger",
+    "hapi",
+    "nlite",
+    "sdk",
+    "monitoring",
+    "observability"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc && cp dist/index.js dist/index.cjs",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@hapi/hapi": ">=20.0.0"
+  },
+  "dependencies": {
+    "@nlite/logger-core": "file:../sdk-core"
+  },
+  "author": "Debanjan Dasgupta",
+  "devDependencies": {
+    "@hapi/hapi": "^21.3.2",
+    "@types/node": "^20.10.0",
+    "eslint": "^8.56.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.1.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,378 @@
+// @ts-nocheck
+// Hapi.js Middleware for NLite Logger
+
+import { Server, Request, ResponseToolkit, Lifecycle } from '@hapi/hapi';
+import { createLogger, FetchTransport, type LoggerSdk, type SdkConfig, type LogLevel, type LogContext, type LogRequest, type LogResponse } from '@nlite/logger-core';
+
+export interface HapiMiddlewareOptions {
+  /** Logger SDK configuration */
+  loggerConfig: SdkConfig;
+  /** Capture request details (default: true) */
+  captureRequest?: boolean;
+  /** Capture response details (default: true) */
+  captureResponse?: boolean;
+  /** Capture errors (default: true) */
+  captureError?: boolean;
+  /** Paths to ignore (default: ['/health', '/ready', '/metrics']) */
+  ignorePaths?: string[];
+  /** Custom tags to add to all logs */
+  customTags?: Record<string, string>;
+  /** Function to extract user ID from request */
+  getUserId?: (request: Request) => string | undefined;
+  /** Function to extract session ID from request */
+  getSessionId?: (request: Request) => string | undefined;
+  /** Function to extract trace ID from request */
+  getTraceId?: (request: Request) => string | undefined;
+}
+
+declare module '@hapi/hapi' {
+  interface Request {
+    nLiteLogger?: LoggerSdk;
+    nLiteLogContext?: {
+      startTime: number;
+      traceId: string;
+      spanId: string;
+    };
+  }
+}
+
+export function createHapiMiddleware(options: HapiMiddlewareOptions) {
+  const {
+    loggerConfig,
+    captureRequest = true,
+    captureResponse = true,
+    captureError = true,
+    ignorePaths = ['/health', '/ready', '/metrics', '/favicon.ico'],
+    customTags = {},
+    getUserId,
+    getSessionId,
+    getTraceId,
+  } = options;
+
+  // Create logger instance
+  const transport = new FetchTransport(loggerConfig.endpoint || 'http://localhost:3000', loggerConfig.apiKey, loggerConfig.headers, loggerConfig.timeout);
+  const logger = createLogger(loggerConfig, transport);
+
+  // Add custom tags
+  logger.setTags(customTags);
+
+  return {
+    name: 'nlite-logger',
+    version: '1.0.0',
+    register: async (server: Server) => {
+      // Store logger on server for access in routes
+      server.decorate('request', 'nLiteLogger', logger);
+
+      // Request logging
+      server.ext('onRequest', (request: Request, h: ResponseToolkit) => {
+        // Skip ignored paths
+        if (ignorePaths.some(path => request.path.startsWith(path))) {
+          return h.continue;
+        }
+
+        const startTime = Date.now();
+        const traceId = getTraceId?.(request) || request.headers['x-trace-id'] || request.headers['trace-id'] || `trace-${startTime}-${Math.random().toString(36).substr(2, 9)}`;
+        const spanId = `span-${startTime}-${Math.random().toString(36).substr(2, 9)}`;
+
+        // Store context
+        request.nLiteLogContext = { startTime, traceId, spanId };
+
+        // Capture request
+        if (captureRequest) {
+          const logRequest: LogRequest = {
+            method: request.method.toUpperCase(),
+            url: `${request.info.host}${request.path}`,
+            path: request.path,
+            query: request.query,
+            headers: sanitizeHeaders(request.headers),
+            body: request.payload ? clonePayload(request.payload) : undefined,
+            ip: request.info.remoteAddress,
+            userAgent: request.headers['user-agent'] || '',
+          };
+
+          logger.addBreadcrumb({
+            type: 'http',
+            category: 'request',
+            message: `${request.method.toUpperCase()} ${request.path}`,
+            data: { method: request.method, path: request.path },
+            level: 'info',
+          });
+
+          // Store for response logging
+          (request as any)._nliteRequest = logRequest;
+        }
+
+        // Set user context if available
+        const userId = getUserId?.(request);
+        if (userId) {
+          logger.setUser(userId);
+        }
+
+        const sessionId = getSessionId?.(request);
+        if (sessionId) {
+          logger.setTags({ sessionId });
+        }
+
+        return h.continue;
+      });
+
+      // Response logging
+      if (captureResponse) {
+        server.ext('onPreResponse', (request: Request, h: ResponseToolkit) => {
+          const response = request.response;
+          const context = request.nLiteLogContext;
+          const logRequest = (request as any)._nliteRequest;
+
+          if (context && logRequest) {
+            const durationMs = Date.now() - context.startTime;
+            const isBoom = response.isBoom;
+
+            const logResponse: LogResponse = {
+              statusCode: isBoom ? response.output.statusCode : (response as any).statusCode || 200,
+              statusText: isBoom ? response.output.payload.error : 'OK',
+              headers: (response as any).headers || {},
+              body: isBoom ? response.output.payload : (response as any).source,
+              durationMs,
+            };
+
+            const level: LogLevel = logResponse.statusCode >= 500 ? 'error' : logResponse.statusCode >= 400 ? 'warn' : 'info';
+
+            logger.log(level, `${request.method.toUpperCase()} ${request.path} ${logResponse.statusCode}`, {
+              request: logRequest,
+              response: logResponse,
+              durationMs,
+              traceId: context.traceId,
+              spanId: context.spanId,
+              userId: getUserId?.(request),
+              sessionId: getSessionId?.(request),
+            });
+          }
+
+          return h.continue;
+        });
+      }
+
+      // Error logging
+      if (captureError) {
+        // Capture request errors using 'request' event with error tags
+        server.events.on('request', (request: Request, event: string, tags: Record<string, boolean>) => {
+          if (tags.error) {
+            const context = request.nLiteLogContext;
+            const logRequest = (request as any)._nliteRequest;
+
+            const errorMessage = typeof event === 'string' ? event : 'Request error';
+            logger.error(errorMessage, new Error(errorMessage), {
+              request: logRequest,
+              traceId: context?.traceId,
+              spanId: context?.spanId,
+              userId: getUserId?.(request),
+              sessionId: getSessionId?.(request),
+              tags: ['hapi', 'request-error'],
+            });
+          }
+        });
+
+        // Capture internal server errors (5xx responses)
+        server.ext('onPreResponse', (request: Request, h: ResponseToolkit) => {
+          const response = request.response;
+          
+          if (response.isBoom && response.output.statusCode >= 500) {
+            const context = request.nLiteLogContext;
+            const logRequest = (request as any)._nliteRequest;
+
+            logger.error(response.message, new Error(response.message), {
+              request: logRequest,
+              traceId: context?.traceId,
+              spanId: context?.spanId,
+              userId: getUserId?.(request),
+              sessionId: getSessionId?.(request),
+              tags: ['hapi', 'server-error'],
+              errorCode: response.output.payload.error,
+            });
+          }
+
+          return h.continue;
+        });
+      }
+
+      // Additional event handlers for comprehensive logging
+      // Log response for all requests (if captureResponse is enabled)
+      if (captureResponse) {
+        server.ext('onPreResponse', (request: Request, h: ResponseToolkit) => {
+          const response = request.response;
+          const context = request.nLiteLogContext;
+          const logRequest = (request as any)._nliteRequest;
+
+          if (context && logRequest) {
+            const durationMs = Date.now() - context.startTime;
+            const isBoom = response.isBoom;
+
+            const logResponse: LogResponse = {
+              statusCode: isBoom ? response.output.statusCode : (response as any).statusCode || 200,
+              statusText: isBoom ? response.output.payload.error : 'OK',
+              headers: (response as any).headers || {},
+              body: isBoom ? response.output.payload : (response as any).source,
+              durationMs,
+            };
+
+            const level: LogLevel = logResponse.statusCode >= 500 ? 'error' : logResponse.statusCode >= 400 ? 'warn' : 'info';
+
+            logger.log(level, `${request.method.toUpperCase()} ${request.path} ${logResponse.statusCode}`, {
+              request: logRequest,
+              response: logResponse,
+              durationMs,
+              traceId: context.traceId,
+              spanId: context.spanId,
+              userId: getUserId?.(request),
+              sessionId: getSessionId?.(request),
+            });
+          }
+
+          return h.continue;
+        });
+      }
+
+      // Log route not found (404)
+      server.ext('onPreResponse', (request: Request, h: ResponseToolkit) => {
+        const response = request.response;
+        if (response.isBoom && response.output.statusCode === 404) {
+          const context = request.nLiteLogContext;
+          const logRequest = (request as any)._nliteRequest;
+          
+          logger.warn(`Route not found: ${request.method.toUpperCase()} ${request.path}`, {
+            request: logRequest,
+            traceId: context?.traceId,
+            spanId: context?.spanId,
+            tags: ['hapi', 'route-not-found'],
+          });
+        }
+        return h.continue;
+      });
+
+      // Log validation errors (400)
+      server.ext('onPreResponse', (request: Request, h: ResponseToolkit) => {
+        const response = request.response;
+        if (response.isBoom && response.output.statusCode === 400) {
+          const context = request.nLiteLogContext;
+          const logRequest = (request as any)._nliteRequest;
+          
+          logger.warn(`Validation error: ${request.method.toUpperCase()} ${request.path}`, {
+            request: logRequest,
+            traceId: context?.traceId,
+            spanId: context?.spanId,
+            tags: ['hapi', 'validation-error'],
+            errorDetails: response.output.payload,
+          });
+        }
+        return h.continue;
+      });
+
+      // Log authentication errors (401, 403)
+      server.ext('onPreResponse', (request: Request, h: ResponseToolkit) => {
+        const response = request.response;
+        if (response.isBoom && (response.output.statusCode === 401 || response.output.statusCode === 403)) {
+          const context = request.nLiteLogContext;
+          const logRequest = (request as any)._nliteRequest;
+          
+          logger.warn(`Auth error ${response.output.statusCode}: ${request.method.toUpperCase()} ${request.path}`, {
+            request: logRequest,
+            traceId: context?.traceId,
+            spanId: context?.spanId,
+            tags: ['hapi', 'auth-error'],
+            errorCode: response.output.payload.error,
+          });
+        }
+        return h.continue;
+      });
+
+      // Log request payload size for large payloads
+      server.ext('onRequest', (request: Request, h: ResponseToolkit) => {
+        if (request.payload && typeof request.payload === 'object') {
+          const payloadSize = JSON.stringify(request.payload).length;
+          if (payloadSize > 10000) { // Log if payload > 10KB
+            logger.debug('Large request payload', {
+              path: request.path,
+              method: request.method,
+              payloadSize,
+              tags: ['hapi', 'large-payload'],
+            });
+          }
+        }
+        return h.continue;
+      });
+
+      // Graceful shutdown
+      server.events.on('stop', async () => {
+        await logger.destroy();
+      });
+    },
+  };
+}
+
+// Helper to access logger in route handlers
+export function getLogger(request: Request): LoggerSdk {
+  return request.nLiteLogger!;
+}
+
+// Plugin options validation
+export const hapiMiddlewareOptionsSchema = {
+  loggerConfig: { required: true },
+  captureRequest: { type: 'boolean', default: true },
+  captureResponse: { type: 'boolean', default: true },
+  captureError: { type: 'boolean', default: true },
+  ignorePaths: { type: 'array', items: 'string', default: ['/health', '/ready', '/metrics'] },
+  customTags: { type: 'object', default: {} },
+  getUserId: { type: 'function' },
+  getSessionId: { type: 'function' },
+  getTraceId: { type: 'function' },
+};
+
+// Utility functions
+function sanitizeHeaders(headers: Record<string, string>): Record<string, string> {
+  const sanitized: Record<string, string> = {};
+  const sensitiveHeaders = ['authorization', 'cookie', 'x-api-key', 'x-auth-token', 'proxy-authorization'];
+  
+  for (const [key, value] of Object.entries(headers)) {
+    if (sensitiveHeaders.includes(key.toLowerCase())) {
+      sanitized[key] = '[REDACTED]';
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+
+function clonePayload(payload: any): any {
+  try {
+    if (typeof payload === 'object' && payload !== null) {
+      return JSON.parse(JSON.stringify(payload));
+    }
+    return payload;
+  } catch {
+    return '[UNCLONEABLE]';
+  }
+}
+
+// Default configuration helper
+export function createDefaultHapiConfig(
+  apiKey: string,
+  appName: string,
+  options: Partial<HapiMiddlewareOptions> = {}
+): HapiMiddlewareOptions {
+  return {
+    loggerConfig: {
+      apiKey,
+      appName,
+      platform: 'backend',
+      environment: (process.env.NODE_ENV as any) || 'development',
+      appVersion: process.env.npm_package_version || '1.0.0',
+      endpoint: process.env.NLITE_ENDPOINT || 'http://localhost:3000',
+      autoCapture: true,
+      ...options.loggerConfig,
+    },
+    ...options,
+  };
+}
+
+// Export types
+export type { LoggerSdk, SdkConfig, LogLevel, LogContext, LogRequest, LogResponse } from '@nlite/logger-core';

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/__tests__/**"]
+}