@eqxjs/nest-logger 3.1.0-beta.13 → 3.1.0-beta.14

package/README.md

@@ -3,23 +3,28 @@
 A comprehensive, production-ready logging module for NestJS applications with built-in OpenTelemetry integration, structured logging, and support for multiple message formats.
 
 [![Version](https://img.shields.io/npm/v/@eqxjs/nest-logger)](https://www.npmjs.com/package/@eqxjs/nest-logger)
-[![Test Coverage](https://img.shields.io/badge/coverage-98.32%25-brightgreen)](./coverage)
+[![Test Coverage](https://img.shields.io/badge/coverage-100%25%20lines-brightgreen)](./coverage)
 [![Node Version](https://img.shields.io/badge/node-%3E%3D22-brightgreen)](https://nodejs.org)
 
 ## Features
 
 ✨ **Key Features:**
 
-- 🚀 **NestJS Integration** - Seamless integration with NestJS framework
-- 📊 **OpenTelemetry Support** - Built-in metrics, traces, and spans
-- 🏷️ **Structured Logging** - Consistent log format with rich metadata
-- 🔒 **Sensitive Data Masking** - Automatic masking of sensitive fields
-- 📝 **Multiple Log Levels** - Debug, Info, Warn, Error, Verbose support
-- 🎯 **Message Formats** - Support for M1, M2, and M3 message protocols
-- ⚡ **Performance Optimized** - Efficient logging with minimal overhead
-- 🧪 **Well Tested** - 98%+ test coverage with 292 test cases
-- 🔍 **Telemetry Metrics** - Counter and histogram metrics for observability
-- 📦 **TypeScript** - Full TypeScript support with type definitions
+- 🚀 **NestJS Integration** - Seamless integration with NestJS framework (v11+)
+- 📊 **OpenTelemetry Support** - Built-in metrics, traces, and spans with distributed tracing
+- 🏷️ **Structured Logging** - Consistent log format with rich metadata (27+ fields)
+- 🔒 **Sensitive Data Masking** - Automatic masking of sensitive fields (password, token, apiKey, etc.)
+- 📝 **Multiple Log Levels** - Debug, Info, Log, Warn, Error, Verbose support with environment filtering
+- 🎯 **Message Formats** - Support for M1 (broker/queue), M2 (HTTP/protocol), and M3 (service) message protocols
+- ⚡ **Performance Optimized** - Efficient logging with caching, fast paths, and minimal overhead
+- 🧪 **Well Tested** - 100% line coverage, 98%+ statement coverage with 297 test cases
+- 🔍 **Telemetry Metrics** - Counter and histogram metrics for observability with configurable filtering
+- 📦 **TypeScript** - Full TypeScript support with comprehensive type definitions and JSDoc
+- ⏱️ **High-Resolution Timing** - Built-in TimeDiff class for precise performance measurements
+- 🎨 **Builder Pattern** - Fluent LoggerDtoBuilder for complex log construction
+- 🌍 **UTC+7 Timezone** - Standardized timestamps with configurable timezone support
+- 🔧 **Message Truncation** - Automatic message truncation (4096 chars) to prevent log overflow
+- 📋 **14 Action Tags** - Predefined action constants for consistent categorization
 
 ## Installation
 
@@ -35,6 +40,46 @@ npm install @eqxjs/nest-logger
 - Node.js >= 22
 - NestJS >= 11
 
+## Feature Overview
+
+### Logger Types Comparison
+
+| Feature | CustomLogger | BaseAppLogger | AppLogger | LoggerFormat (M1/M2/M3) |
+|---------|--------------|---------------|-----------|-------------------------|
+| **Basic Logging** | ✅ | ✅ | ✅ | ✅ |
+| **Structured Metadata** | ❌ | ✅ | ✅ | ✅ |
+| **OpenTelemetry** | ❌ | ✅ | ✅ | ✅ |
+| **Message Formats** | ❌ | ❌ | ✅ | ✅ |
+| **Summary Logs** | ❌ | ✅ | ✅ | ✅ |
+| **Sensitive Masking** | ✅ | ✅ | ✅ | ✅ |
+| **Use Case** | Simple apps | Advanced apps | Multi-format | Specific protocols |
+
+### Supported Log Levels
+
+All loggers support these levels (controlled by `LOG_LEVEL` environment variable):
+
+- **debug** - Detailed diagnostic information
+- **info** - General informational messages
+- **log** - Alias for info level
+- **warn** - Warning messages for potentially harmful situations
+- **error** - Error events that might still allow the app to continue
+- **verbose** - Most detailed information for deep debugging
+
+
+### Metadata Fields
+
+LoggerDto includes 27+ fields for comprehensive logging:
+
+| Category | Fields |
+|----------|--------|
+| **Core** | level, timestamp, message, action |
+| **Application** | appName, componentName, componentVersion |
+| **Tracking** | sessionId, transactionId, recordName, guid |
+| **Context** | channel, broker, device, user, public |
+| **Use Case** | useCase, useCaseStep |
+| **Result** | appResult, appResultCode, serviceTime, stack |
+| **Infrastructure** | instance, originateServiceName, recordType |
+
 ## Quick Start
 
 ### 1. Import the Module
@@ -69,6 +114,116 @@ export class MyService {
 }
 ```
 
+## Message Protocol Data Structures
+
+The logger supports three message protocols (M1, M2, M3), each with specific required properties:
+
+### DataM1I - Broker/Queue Messages
+
+**Required Properties:**
+- `header`: DataHeaderI - Message header with identity
+- `protocol`: DataProtocolI - Protocol-specific information
+- `body`: Record<string, unknown> - Message payload
+
+```typescript
+import { DataM1I } from '@eqxjs/nest-logger';
+
+const data: DataM1I = {
+  header: {
+    sessionId: 'session-123',
+    transactionId: 'txn-456',
+    broker: 'kafka',
+    channel: 'order-queue',
+    useCase: 'ProcessOrder',
+    identity: {
+      device: 'mobile-app',
+      user: 'user-123',
+      public: 'public-id'
+    }
+  },
+  protocol: {
+    topic: 'order.created',
+    command: 'PROCESS',
+    qos: '1'
+  },
+  body: {
+    orderId: '12345',
+    amount: 100.00
+  }
+};
+```
+
+### DataM2I - HTTP/Protocol Messages
+
+**Required Properties:**
+- `header`: DataHeaderI - Message header with identity
+- `body`: Record<string, unknown> - Message payload
+
+**Optional Properties:**
+- `protocol`: DataProtocolI - HTTP/protocol information
+
+```typescript
+import { DataM2I } from '@eqxjs/nest-logger';
+
+const data: DataM2I = {
+  header: {
+    sessionId: 'session-123',
+    transactionId: 'txn-456',
+    channel: 'web',
+    useCase: 'CreatePayment',
+    identity: {
+      user: 'user-123',
+      public: 'public-id'
+    }
+  },
+  body: {
+    paymentId: 'pay-123',
+    status: 'completed'
+  }
+};
+```
+
+### DataM3I - Service/Database Messages
+
+**Required Properties:**
+- `service`: DataServiceI - Service-specific information with identity
+- `body`: Record<string, unknown> - Message payload
+
+**Optional Properties:**
+- `header`: DataHeaderI - Message header with identity
+
+```typescript
+import { DataM3I } from '@eqxjs/nest-logger';
+
+const data: DataM3I = {
+  service: {
+    serviceName: 'PostgreSQL',
+    name: 'users-db',
+    invoke: 'SELECT',
+    identity: {
+      device: 'db-server-1',
+      user: 'db-user'
+    }
+  },
+  body: {
+    query: 'SELECT * FROM users WHERE id = $1',
+    resultCount: 1
+  }
+};
+```
+
+### Identity Structure
+
+All message types include an `identity` object with optional fields:
+
+```typescript
+identity: {
+  device?: string | string[];  // Device identifier(s)
+  public?: string;             // Public identifier
+  user?: string;               // User identifier
+}
+```
+
 ## Usage Examples
 
 ### Basic Logging
@@ -114,11 +269,11 @@ export class PaymentController {
         transactionId,
         channel: 'web',
         useCase: 'ProcessPayment',
+        identity: {},
       },
-      protocol: {
-        method: request.method,
-        path: request.path,
-        statusCode: 200,
+      body: {
+        amount: request.body.amount,
+        currency: request.body.currency,
       },
     };
 
@@ -182,6 +337,15 @@ export class OrderConsumer {
         channel: 'order-topic',
         useCase: 'ProcessOrder',
         useCaseStep: 'Consume',
+        identity: {},
+      },
+      protocol: {
+        topic: 'order.created',
+        command: 'CONSUME',
+      },
+      body: {
+        orderId: message.orderId,
+        customerId: message.customerId,
       },
     };
 
@@ -250,15 +414,16 @@ export class UserRepository {
     const timer = new TimeDiff();
 
     const data: DataM3I = {
-      header: {
-        sessionId,
-        transactionId,
-        useCase: 'GetUser',
-      },
+
       service: {
         serviceName: 'PostgreSQL',
-        operation: 'SELECT',
-        table: 'users',
+        invoke: 'SELECT',
+        name: 'users',
+        identity: {},
+      },
+      body: {
+        userId: userId,
+        operation: 'findById',
       },
     };
 
@@ -320,12 +485,6 @@ export class NotificationService {
     const timer = new TimeDiff();
 
     const data: DataM3I = {
-      header: {
-        sessionId,
-        transactionId,
-        useCase: 'SendNotification',
-        useCaseStep: 'SendEmail',
-      },
       service: {
         serviceName: 'EmailService',
         operation: 'SEND',
@@ -644,6 +803,15 @@ export class KafkaConsumerService {
         broker: 'kafka',
         channel: 'queue',
         useCase: 'MessageProcessing',
+        identity: {},
+      },
+      protocol: {
+        topic: 'payment.topic',
+        command: 'PROCESS',
+      },
+      body: {
+        messageId: message.id,
+        payload: message.data,
       },
     };
 
@@ -681,12 +849,17 @@ export class HttpService {
       header: {
         sessionId: req.sessionId,
         transactionId: req.transactionId,
+        identity: {},
       },
       protocol: {
         requestId: req.id,
         method: req.method,
         path: req.path,
       },
+      body: {
+        endpoint: req.path,
+        params: req.params,
+      },
     };
 
     this.logger.loggerM2.info(
@@ -713,11 +886,17 @@ export class DatabaseService {
       header: {
         sessionId: 'session-123',
         transactionId: 'txn-456',
+        identity: {},
       },
       service: {
         serviceName: 'PostgreSQL',
-        operation: 'SELECT',
-        table: 'users',
+        invoke: 'SELECT',
+        name: 'users',
+        identity: {},
+      },
+      body: {
+        query: query,
+        database: 'users_db',
       },
     };
 
@@ -828,25 +1007,31 @@ const manualMask = JSON.stringify(sensitiveData, maskMessageReplacer);
 
 ### Environment Variables
 
-```bash
-# Log levels (comma-separated)
-LOG_LEVEL=debug,info,warn,error,verbose
+Configure the logger behavior using these environment variables:
 
-# Sensitive field masking (comma-separated)
-LOG_MASK_KEYS=password,secret,token,apiKey
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `LOG_LEVEL` | string | - | Comma-separated list of enabled log levels: `debug,info,log,warn,error,verbose` |
+| `LOG_MASK_KEYS` | string | - | Comma-separated list of field names to mask (e.g., `password,token,apiKey,secret`) |
+| `APP_VERSION` | string | - | Application version included in telemetry and logs |
+| `DESTINATION` | string | - | Deployment destination/environment name |
+| `TELEMETRY_IGNORE_CODE` | string | - | Comma-separated list of result codes to exclude from telemetry metrics |
 
-# Application version for telemetry
-APP_VERSION=1.0.0
+**Example Configuration:**
 
-# Telemetry destination
+```bash
+# .env file
+LOG_LEVEL=debug,info,warn,error,verbose
+LOG_MASK_KEYS=password,secret,token,apiKey,creditCard,ssn
+APP_VERSION=1.0.0
 DESTINATION=production
-
-# Ignore specific result codes from telemetry
-TELEMETRY_IGNORE_CODE=404,401
+TELEMETRY_IGNORE_CODE=404,401,403
 ```
 
 ### Log Level Filtering
 
+Control which log levels are output by configuring the `LOG_LEVEL` environment variable:
+
 ```typescript
 // Only logs matching the LOG_LEVEL env var will be output
 process.env.LOG_LEVEL = 'info,error';
@@ -854,22 +1039,58 @@ process.env.LOG_LEVEL = 'info,error';
 logger.debug('This will NOT be logged');
 logger.info('This WILL be logged');
 logger.error('This WILL be logged');
+logger.verbose('This will NOT be logged');
 ```
 
 ### Sensitive Data Masking
 
+Protect sensitive information by automatically masking specified fields:
+
 ```typescript
 // Set masked fields via environment
-process.env.LOG_MASK_KEYS = 'password,creditCard,ssn';
+process.env.LOG_MASK_KEYS = 'password,creditCard,ssn,token';
 
 const userData = {
   username: 'john',
   password: 'secret123',
   creditCard: '4111-1111-1111-1111',
+  email: 'john@example.com',
+  token: 'abc-def-123'
 };
 
 logger.log(userData);
-// Output: { username: 'john', password: '*****', creditCard: '*****' }
+// Output: { username: 'john', password: '*****', creditCard: '*****', email: 'john@example.com', token: '*****' }
+```
+
+### Telemetry Filtering
+
+Exclude specific result codes from telemetry metrics to reduce noise:
+
+```typescript
+// Don't track 404 and 401 errors in telemetry
+process.env.TELEMETRY_IGNORE_CODE = '404,401';
+
+// These won't be recorded in OpenTelemetry metrics
+logger.app.summaryError('Not found', '404', 100);
+logger.app.summaryError('Unauthorized', '401', 50);
+
+// This will be recorded
+logger.app.summaryError('Server error', '500', 200);
+```
+
+### Message Truncation
+
+Long messages are automatically truncated to prevent log overflow:
+
+```typescript
+// Messages longer than 4096 characters are truncated
+const longMessage = 'a'.repeat(5000);
+logger.info(longMessage);
+// Logged message will be truncated to 4096 chars + '...'
+
+// The limit is defined in DEFAULT_VALUES.MAX_MESSAGE_LENGTH
+import { DEFAULT_VALUES } from '@eqxjs/nest-logger';
+console.log(DEFAULT_VALUES.MAX_MESSAGE_LENGTH); // 4096
 ```
 
 ## OpenTelemetry Integration
@@ -1323,41 +1544,388 @@ class LoggerDto {
 
 ## Best Practices
 
-1. **Use Appropriate Log Levels**
-   - `debug`: Detailed diagnostic information
-   - `info`: General informational messages
-   - `warn`: Warning messages for potentially harmful situations
-   - `error`: Error events that might still allow the application to continue
-   - `verbose`: Most detailed information
-
-2. **Include Context**
-   ```typescript
-   // Good
-   logger.log('User created', 'UserService');
-   
-   // Better
-   logger.app.info(
-     'User created successfully',
-     '[USER_CREATE]',
-     'UserService',
-     'user-123'
-   );
-   ```
-
-3. **Use Summary Logging for Operations**
-   ```typescript
-   // Track operation duration and success/failure
-   const timer = new TimeDiff();
-   try {
-     await operation();
-     logger.app.summarySuccess('Success', '200', timer.diff());
-   } catch (error) {
-     logger.app.summaryError('Failed', '500', timer.diff(), ..., [error.stack]);
-   }
-   ```
-
-4. **Leverage Message Formats**
-   - Use M1 for message queue/broker operations
+### 1. Choose the Right Logger
+
+```typescript
+// For simple applications - use CustomLogger
+const logger = new CustomLogger('MyApp');
+logger.log('Simple message');
+
+// For structured logging - use BaseAppLogger
+const appLogger = new BaseAppLogger('MyApp', 'UserService');
+appLogger.info('User action', '[USER_CREATE]');
+
+// For multiple formats - use AppLogger
+const multiLogger = new AppLogger('MyApp');
+multiLogger.app.info('Standard log');
+multiLogger.loggerM1.info('kafka.topic', '[CONSUMING]', data);
+```
+
+### 2. Use Appropriate Log Levels
+
+Choose the right level based on the situation:
+
+```typescript
+// DEBUG - Detailed diagnostic information (development only)
+logger.debug('Request payload:', { userId: 123, action: 'create' });
+
+// INFO - General informational messages (normal operations)
+logger.info('User logged in successfully', '[USER_LOGIN]');
+
+// WARN - Potentially harmful situations (recoverable issues)
+logger.warn('API rate limit approaching 80%', '[RATE_LIMIT]');
+
+// ERROR - Error events that might still allow the app to continue
+logger.error('Failed to send email notification', '[EMAIL_ERROR]');
+
+// VERBOSE - Most detailed information (deep debugging only)
+logger.verbose('Internal state:', { state: complexObject });
+```
+
+### 3. Include Meaningful Context
+
+Always provide context to make logs searchable and traceable:
+
+```typescript
+// ❌ Bad - No context
+logger.log('User created');
+
+// ✅ Good - With context
+logger.log('User created', 'UserService');
+
+// ✅ Better - Structured with action tag
+logger.app.info(
+  'User created successfully',
+  '[USER_CREATE]',
+  'UserService',
+  'user-123'  // recordName
+);
+
+// ✅ Best - Full metadata for distributed tracing
+logger.app.info(
+  'User created successfully',
+  '[USER_CREATE]',
+  'UserService',
+  'user-123',      // recordName
+  'sess-456',      // sessionId
+  'txn-789',       // transactionId
+  'mobile',        // channel
+  '1.0.0',         // componentVersion
+  'CreateUser',    // useCase
+  'Complete'       // useCaseStep
+);
+```
+
+### 4. Use Summary Logging for Operations
+
+Track operation duration and outcomes with summary logs:
+
+```typescript
+// ✅ Best Practice - Track operation with telemetry
+const timer = new TimeDiff();
+
+try {
+  const result = await operation();
+  
+  // Log success with metrics (automatically creates OpenTelemetry data)
+  logger.app.summarySuccess(
+    'Operation completed',
+    '200',
+    timer.diff(),
+    'ServiceName',
+    'record-123',
+    sessionId,
+    transactionId
+  );
+  
+  return result;
+} catch (error) {
+  // Log error with stack trace and metrics
+  logger.app.summaryError(
+    'Operation failed',
+    error.code || '500',
+    timer.diff(),
+    'ServiceName',
+    'record-123',
+    sessionId,
+    transactionId,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    [error.stack]  // Include stack trace
+  );
+  
+  throw error;
+}
+```
+
+### 5. Leverage Message Formats
+
+Use the appropriate format for your use case:
+
+```typescript
+// ✅ M1 for message broker/queue operations
+logger.loggerM1.info(
+  'order.created',
+  ActionMessage.consume(),
+  dataM1,
+  'Processing order message'
+);
+
+// ✅ M2 for HTTP/protocol operations
+logger.loggerM2.info(
+  'api.users',
+  ActionMessage.httpRequest(),
+  dataM2,
+  'POST /api/users'
+);
+
+// ✅ M3 for database/service operations
+logger.loggerM3.debug(
+  'db.users',
+  ActionMessage.dbRequest(),
+  dataM3,
+  'SELECT * FROM users WHERE id = ?'
+);
+```
+
+### 6. Use Action Constants
+
+Leverage predefined action tags for consistency:
+
+```typescript
+import { ActionMessage } from '@eqxjs/nest-logger';
+
+// ✅ Use constants instead of strings
+logger.info('Message received', ActionMessage.consume());
+logger.info('Request sent', ActionMessage.httpRequest());
+logger.error('Exception occurred', ActionMessage.exception());
+
+// ❌ Avoid - Manual strings (typos, inconsistency)
+logger.info('Message received', '[CONSUMMING]');  // Typo!
+logger.info('Request sent', '[HTTP-REQUEST]');    // Wrong format
+```
+
+### 7. Mask Sensitive Data
+
+Configure masking to protect sensitive information:
+
+```typescript
+// Set up masking in environment
+process.env.LOG_MASK_KEYS = 'password,apiKey,token,creditCard,ssn';
+
+// ✅ All sensitive fields will be automatically masked
+const user = {
+  username: 'john',
+  password: 'secret123',  // Will be masked
+  email: 'john@example.com'
+};
+
+logger.info('User data', user);
+// Output: { username: 'john', password: '*****', email: 'john@example.com' }
+```
+
+### 8. Configure Environment Variables
+
+Set up proper configuration for each environment:
+
+```typescript
+// Development
+process.env.LOG_LEVEL = 'debug,info,log,warn,error,verbose';
+process.env.LOG_MASK_KEYS = 'password,token';
+process.env.TELEMETRY_IGNORE_CODE = '';
+
+// Production
+process.env.LOG_LEVEL = 'info,warn,error';
+process.env.LOG_MASK_KEYS = 'password,token,apiKey,secret,creditCard,ssn';
+process.env.TELEMETRY_IGNORE_CODE = '404,401,403';
+process.env.APP_VERSION = '1.0.0';
+process.env.DESTINATION = 'production';
+```
+
+### 9. Use TimeDiff for Performance Tracking
+
+Measure and log operation performance:
+
+```typescript
+import { TimeDiff } from '@eqxjs/nest-logger';
+
+// ✅ Track operation duration
+async function processData() {
+  const timer = TimeDiff.start();
+  
+  // Step 1
+  await step1();
+  logger.debug(`Step 1 completed in ${timer.diff()}ms`);
+  
+  // Step 2
+  await step2();
+  logger.debug(`Step 2 completed in ${timer.diff()}ms`);
+  
+  // Total time
+  const total = timer.end();
+  logger.info(`Total processing time: ${total}ms`);
+}
+```
+
+### 10. Handle Errors Consistently
+
+Establish a consistent pattern for error handling:
+
+```typescript
+async function businessOperation() {
+  const timer = new TimeDiff();
+  const sessionId = 'sess-123';
+  const transactionId = 'txn-456';
+  
+  try {
+    logger.app.info(
+      'Starting operation',
+      ActionMessage.appLogic(),
+      'MyService',
+      'record-123',
+      sessionId,
+      transactionId
+    );
+    
+    const result = await performOperation();
+    
+    logger.app.summarySuccess(
+      'Operation successful',
+      '200',
+      timer.diff(),
+      'MyService',
+      'record-123',
+      sessionId,
+      transactionId
+    );
+    
+    return result;
+    
+  } catch (error) {
+    logger.app.error(
+      `Operation failed: ${error.message}`,
+      ActionMessage.exception(),
+      'MyService',
+      'record-123',
+      sessionId,
+      transactionId
+    );
+    
+    logger.app.summaryError(
+      'Operation failed',
+      error.code || '500',
+      timer.diff(),
+      'MyService',
+      'record-123',
+      sessionId,
+      transactionId,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      [error.stack]
+    );
+    
+    throw error;
+  }
+}
+```
+
+## Performance Considerations
+
+- **Caching**: Logger caches hostname and app version for performance
+- **Fast Paths**: String messages use optimized fast paths
+- **Message Truncation**: Long messages automatically truncated to 4096 chars
+- **Level Filtering**: Disabled log levels have minimal overhead (early return)
+- **Lazy Evaluation**: Complex operations only performed for enabled levels
+
+## Troubleshooting
+
+### Logs Not Appearing
+
+Check that the log level is enabled:
+
+```typescript
+process.env.LOG_LEVEL = 'debug,info,warn,error,verbose';
+// Make sure the level you're using is in this list
+```
+
+### Sensitive Data Still Visible
+
+Ensure masking is configured:
+
+```typescript
+process.env.LOG_MASK_KEYS = 'password,token,apiKey,secret';
+// Add all field names that should be masked
+```
+
+### Telemetry Not Working
+
+Verify OpenTelemetry is configured in your application and the result codes aren't ignored:
+
+```typescript
+// Check if code is in ignore list
+process.env.TELEMETRY_IGNORE_CODE = '404,401';
+// These codes won't be tracked in telemetry
+```
+
+### TypeScript Type Errors
+
+Import the correct interfaces:
+
+```typescript
+import { 
+  DataM1I, 
+  DataM2I, 
+  DataM3I,
+  LoggerOpt 
+} from '@eqxjs/nest-logger';
+```
+
+## Testing
+
+The module includes comprehensive test coverage (100% lines):
+
+```bash
+# Run tests
+yarn test
+
+# Run tests with coverage
+yarn test:cov
+
+# Watch mode
+yarn test:watch
+```
+
+## Development
+
+Please see [docs/README.md](docs/README.md) for development guidelines.
+
+## Contributing
+
+Please see [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.
+
+## License
+
+ISC
+
+## Support
+
+For issues, questions, or contributions, please visit the [GitHub repository](https://github.com/eqxjs/nest-logger).
+
+## Changelog
+
+See [CHANGELOG](CHANGELOG) for release notes and version history.
+
+---
+
+**Made with ❤️ by the EQXJS Team**
    - Use M2 for HTTP/protocol-specific operations
    - Use M3 for service-to-service operations