[RFC] Logging & Monitoring Module

[Evanion]

Overview

A module to provide logging and monitoring integrations (Winston, Pino, Sentry, Application Insights, etc.) for NexusDI, with injectable loggers/clients and optional decorators for error reporting, tracing, and context propagation.

Motivation

• Centralized, injectable logging/monitoring: Make it easy to inject and mock loggers or monitoring clients in services.
• Support for multiple providers: Allow users to choose their preferred logger and monitoring backend.
• Declarative error reporting and tracing: Use decorators for error reporting, tracing, and context propagation.
• Extensibility: Enable advanced features (structured logging, log levels, async error reporting, etc.) and pass options directly to providers.

Proposed Features

• Register logger/monitoring providers via config (e.g., in container.json)
• Inject loggers/clients into services using @InjectLogger() or @InjectMonitor()
• Support for multiple named loggers/monitors (e.g., default, audit, etc.)
• Decorators for error reporting (@ReportError()), tracing (@Trace()), and context propagation
• Support for structured logging, log levels, and context
• Pass all options/config down to the underlying logger/monitoring provider
• Easy mocking/overriding of loggers/monitors for testing

Example Workflow

1. Configure the logging/monitoring module in container.json:

   {
     "logging": {
       "default": {
         "provider": "winston",
         "level": "info",
         "transports": [
           { "type": "console" }
         ]
       },
       "audit": {
         "provider": "pino",
         "level": "warn"
       }
     },
     "monitoring": {
       "sentry": {
         "dsn": "https://examplePublicKey@o0.ingest.sentry.io/0"
       },
       "appInsights": {
         "instrumentationKey": "YOUR_INSTRUMENTATION_KEY"
       }
     }
   }

2. Register the logging/monitoring module:

   import { LoggingModule, MonitoringModule } from '@nexusdi/logging';
   
   container.set(LoggingModule.configFromFile('container.json'));
   container.set(MonitoringModule.configFromFile('container.json'));

3. Inject loggers/monitors and use decorators:

   import { InjectLogger, ReportError, Trace } from '@nexusdi/logging';
   
   class OrderService {
     constructor(@InjectLogger() private logger: Logger) {}
   
     @ReportError()
     @Trace()
     async processOrder(order: Order) {
       this.logger.info('Processing order', { orderId: order.id });
       // ... business logic ...
     }
   }
   
   import { InjectMonitor } from '@nexusdi/logging';
   
   class UserService {
     constructor(@InjectMonitor('sentry') private sentry: SentryClient) {}
   
     async riskyOperation() {
       try {
         // ... risky code ...
       } catch (err) {
         this.sentry.captureException(err);
       }
     }
   }

Open Questions

• Which logging and monitoring providers should be supported out of the box (Winston, Pino, Sentry, Application Insights, etc.)?
• Should we provide a unified logger/monitor interface, or allow provider-specific APIs?
• How should async error reporting and context propagation be handled?
• Should we provide additional decorators for log levels, context, or custom tags?
• How to best support mocking/overriding loggers/monitors for testing?

API Sketch

import { InjectLogger, ReportError, Trace } from '@nexusdi/logging';

class OrderService {
  constructor(@InjectLogger() private logger: Logger) {}

  @ReportError()
  @Trace()
  async processOrder(order: Order) {
    this.logger.info('Processing order', { orderId: order.id });
    // ... business logic ...
  }
}

import { InjectMonitor } from '@nexusdi/logging';

class UserService {
  constructor(@InjectMonitor('sentry') private sentry: SentryClient) {}

  async riskyOperation() {
    try {
      // ... risky code ...
    } catch (err) {
      this.sentry.captureException(err);
    }
  }
}

Call for Feedback

• What logging/monitoring providers do you use or want supported?
• What features or decorators would you want for logging and monitoring?
• Any pain points with logging/monitoring in DI frameworks?
• How important is support for structured logging, context, or advanced features?
• Any other features or decorator options you’d want?