@opensourcekd/ng-common-libs 2.0.5 → 2.0.7

package/README.md

@@ -23,6 +23,7 @@ import {
 
 - **AuthService**: Complete Auth0 authentication with token management (Pure TypeScript - no Angular dependency)
 - **EventBus**: Framework-agnostic event bus using RxJS
+- **Logger**: OpenTelemetry-compliant structured logging with observable log streams
 - **Works with any framework**: Angular, React, Vue, Svelte, vanilla JS
 - **Module Federation Support**: Singleton pattern works across shell + MFEs
 - **Zero Framework Lock-in**: Core services are pure TypeScript classes
@@ -94,6 +95,7 @@ import {
   // Services
   AuthService,
   EventBus,
+  Logger,
   
   // Helper Functions
   configureAuth0,
@@ -121,6 +123,10 @@ import {
   AppState,
   AuthorizationParams,
   CallbackResult,
+  LogRecord,
+  LogAttributes,
+  LogSeverity,
+  LoggerOptions,
 } from '@opensourcekd/ng-common-libs';
 ```
 

package/dist/index.cjs

@@ -12,6 +12,9 @@ var operators = require('rxjs/operators');
  * // Create an instance
  * const eventBus = new EventBus();
  *
+ * // Create an instance with an identifier
+ * const eventBus = new EventBus({ id: 'MFE' });
+ *
  * // Emit an event
  * eventBus.emit('user:login', { userId: '123', username: 'john' });
  *
@@ -19,10 +22,28 @@ var operators = require('rxjs/operators');
  * eventBus.on('user:login').subscribe(data => {
  *   console.log('User logged in:', data);
  * });
+ *
+ * // Get the identifier
+ * const id = eventBus.getId(); // 'MFE' or undefined
  * ```
  */
 class EventBus {
     eventSubject = new rxjs.Subject();
+    id;
+    /**
+     * Create a new EventBus instance
+     * @param options - Optional configuration with an id to identify the instance
+     */
+    constructor(options) {
+        this.id = options?.id;
+    }
+    /**
+     * Get the identifier of this EventBus instance
+     * @returns The id if provided during initialization, undefined otherwise
+     */
+    getId() {
+        return this.id;
+    }
     /**
      * Emit an event with optional data
      * @param eventType - The type/name of the event
@@ -245,10 +266,16 @@ function removeStorageItem(key, storageType = 'sessionStorage') {
  * };
  * const authService = new AuthService(authConfig, eventBus);
  *
+ * // Or create with an identifier
+ * const authService = new AuthService(authConfig, eventBus, undefined, undefined, { id: 'MFE' });
+ *
  * // Use the service
  * await authService.login();
  * const user = authService.getUser();
  * const token = await authService.getToken();
+ *
+ * // Get the identifier
+ * const id = authService.getId(); // 'MFE' or undefined
  * ```
  */
 class AuthService {
@@ -267,12 +294,14 @@ class AuthService {
     storageConfig;
     storageKeys;
     eventBus;
+    id;
     /**
      * Create a new AuthService instance
      * @param config - Auth0 configuration
      * @param eventBus - EventBus instance for emitting auth events
      * @param storageConfig - Storage configuration (optional, defaults to sessionStorage)
      * @param storageKeys - Storage keys (optional, defaults to standard keys)
+     * @param options - Optional configuration with an id to identify the instance
      */
     constructor(config, eventBus, storageConfig = {
         TOKEN_STORAGE: 'sessionStorage',
@@ -280,16 +309,24 @@ class AuthService {
     }, storageKeys = {
         ACCESS_TOKEN: 'auth0_access_token',
         USER_INFO: 'auth0_user_info'
-    }) {
+    }, options) {
         this.config = config;
         this.eventBus = eventBus;
         this.storageConfig = storageConfig;
         this.storageKeys = storageKeys;
+        this.id = options?.id;
         this.userSubject = new rxjs.BehaviorSubject(this.getUserInfoFromStorage());
         this.user$ = this.userSubject.asObservable();
         console.log("[AuthService] AuthService instance created (Auth0 client will be initialized on first use)");
         // Lazy initialization - Auth0 client will be initialized in ensureInitialized() on first use
     }
+    /**
+     * Get the identifier of this AuthService instance
+     * @returns The id if provided during initialization, undefined otherwise
+     */
+    getId() {
+        return this.id;
+    }
     /**
      * Initialize Auth0 client
      */
@@ -406,6 +443,8 @@ class AuthService {
             }
             const token = await this.auth0Client.getTokenSilently();
             this.setToken(token);
+            // Clean up OAuth callback parameters from URL
+            this.cleanupCallbackUrl();
             console.log("[AuthService] Authentication successful");
             this.emitAuthEvent('login_success', { user, appState: result.appState });
             return { success: true, appState: result.appState };
@@ -628,6 +667,34 @@ class AuthService {
         this.eventBus.emit(event.type, event);
         console.log('[AuthService] Auth event emitted:', event.type);
     }
+    /**
+     * Clean up OAuth callback parameters from URL after successful authentication
+     * Removes 'code' and 'state' parameters while preserving other query parameters
+     */
+    cleanupCallbackUrl() {
+        try {
+            const url = new URL(window.location.href);
+            const params = new URLSearchParams(url.search);
+            // Check if OAuth params exist
+            const hasCode = params.has('code');
+            const hasState = params.has('state');
+            if (hasCode || hasState) {
+                // Remove OAuth callback parameters
+                params.delete('code');
+                params.delete('state');
+                // Construct new URL without OAuth params
+                const newSearch = params.toString();
+                const newUrl = `${url.pathname}${newSearch ? '?' + newSearch : ''}${url.hash}`;
+                // Replace URL without adding to browser history
+                window.history.replaceState({}, '', newUrl);
+                console.log('[AuthService] OAuth callback parameters cleaned from URL');
+            }
+        }
+        catch (error) {
+            console.warn('[AuthService] Failed to clean up callback URL:', error);
+            // Don't throw - URL cleanup is not critical for auth functionality
+        }
+    }
 }
 /**
  * Create AuthService instance using AUTH0_CONFIG
@@ -667,10 +734,215 @@ function createAuthService(eventBus) {
     return new AuthService(auth0Config, eventBus, STORAGE_CONFIG, STORAGE_KEYS);
 }
 
+/**
+ * OpenTelemetry severity levels
+ * Based on OpenTelemetry log data model
+ * @see https://opentelemetry.io/docs/specs/otel/logs/data-model/
+ */
+exports.LogSeverity = void 0;
+(function (LogSeverity) {
+    LogSeverity[LogSeverity["TRACE"] = 1] = "TRACE";
+    LogSeverity[LogSeverity["DEBUG"] = 5] = "DEBUG";
+    LogSeverity[LogSeverity["INFO"] = 9] = "INFO";
+    LogSeverity[LogSeverity["WARN"] = 13] = "WARN";
+    LogSeverity[LogSeverity["ERROR"] = 17] = "ERROR";
+    LogSeverity[LogSeverity["FATAL"] = 21] = "FATAL";
+})(exports.LogSeverity || (exports.LogSeverity = {}));
+/**
+ * Logger - OpenTelemetry-compliant structured logging
+ * Framework-agnostic implementation using RxJS for observability
+ *
+ * Conforms to OpenTelemetry log data model:
+ * - Structured logging with severity levels
+ * - Timestamp in milliseconds
+ * - Support for attributes and resource context
+ * - Observable log stream for integration with OTel exporters
+ *
+ * @example
+ * ```typescript
+ * // Create a logger instance
+ * const logger = new Logger({
+ *   name: 'MyService',
+ *   minSeverity: LogSeverity.INFO,
+ *   resource: {
+ *     'service.name': 'my-app',
+ *     'deployment.environment': 'production'
+ *   }
+ * });
+ *
+ * // Simple logging
+ * logger.info('User logged in');
+ * logger.error('Failed to fetch data');
+ *
+ * // Structured logging with attributes
+ * logger.info('User action', {
+ *   userId: '123',
+ *   action: 'purchase',
+ *   amount: 99.99
+ * });
+ *
+ * // Subscribe to log stream (e.g., for sending to OTel collector)
+ * logger.getLogStream().subscribe(logRecord => {
+ *   // Send to OTel exporter, custom backend, etc.
+ *   console.log(JSON.stringify(logRecord));
+ * });
+ *
+ * // Log with trace correlation
+ * logger.info('Processing request',
+ *   { requestId: 'abc-123' },
+ *   { traceId: '1234...', spanId: '5678...' }
+ * );
+ * ```
+ */
+class Logger {
+    logSubject = new rxjs.Subject();
+    name;
+    minSeverity;
+    resource;
+    consoleOutput;
+    /**
+     * Create a new Logger instance
+     * @param options - Optional configuration for the logger
+     */
+    constructor(options) {
+        this.name = options?.name;
+        this.minSeverity = options?.minSeverity ?? exports.LogSeverity.TRACE;
+        this.resource = options?.resource;
+        this.consoleOutput = options?.consoleOutput ?? true;
+    }
+    /**
+     * Get the logger name
+     * @returns The logger name if provided during initialization
+     */
+    getName() {
+        return this.name;
+    }
+    /**
+     * Get the observable log stream
+     * Subscribe to this to receive all log records emitted by this logger
+     * @returns Observable that emits LogRecord objects
+     */
+    getLogStream() {
+        return this.logSubject.asObservable();
+    }
+    /**
+     * Emit a log record
+     * @param severity - Severity level
+     * @param severityText - Severity level text
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context (traceId, spanId)
+     */
+    log(severity, severityText, body, attributes, context) {
+        // Check if we should log based on minimum severity
+        if (severity < this.minSeverity) {
+            return;
+        }
+        const logRecord = {
+            timestamp: Date.now(),
+            severityNumber: severity,
+            severityText,
+            body,
+            attributes,
+            traceId: context?.traceId,
+            spanId: context?.spanId,
+            resource: this.resource
+        };
+        // Emit to observable stream
+        this.logSubject.next(logRecord);
+        // Console output if enabled
+        if (this.consoleOutput) {
+            this.outputToConsole(logRecord);
+        }
+    }
+    /**
+     * Output log to console
+     * @param logRecord - The log record to output
+     */
+    outputToConsole(logRecord) {
+        const prefix = this.name ? `[${this.name}]` : '';
+        const message = `${prefix} ${logRecord.body}`;
+        const meta = logRecord.attributes;
+        switch (logRecord.severityNumber) {
+            case exports.LogSeverity.TRACE:
+            case exports.LogSeverity.DEBUG:
+                console.debug(message, meta);
+                break;
+            case exports.LogSeverity.INFO:
+                console.info(message, meta);
+                break;
+            case exports.LogSeverity.WARN:
+                console.warn(message, meta);
+                break;
+            case exports.LogSeverity.ERROR:
+            case exports.LogSeverity.FATAL:
+                console.error(message, meta);
+                break;
+            default:
+                console.log(message, meta);
+        }
+    }
+    /**
+     * Log a TRACE level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    trace(body, attributes, context) {
+        this.log(exports.LogSeverity.TRACE, 'TRACE', body, attributes, context);
+    }
+    /**
+     * Log a DEBUG level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    debug(body, attributes, context) {
+        this.log(exports.LogSeverity.DEBUG, 'DEBUG', body, attributes, context);
+    }
+    /**
+     * Log an INFO level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    info(body, attributes, context) {
+        this.log(exports.LogSeverity.INFO, 'INFO', body, attributes, context);
+    }
+    /**
+     * Log a WARN level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    warn(body, attributes, context) {
+        this.log(exports.LogSeverity.WARN, 'WARN', body, attributes, context);
+    }
+    /**
+     * Log an ERROR level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    error(body, attributes, context) {
+        this.log(exports.LogSeverity.ERROR, 'ERROR', body, attributes, context);
+    }
+    /**
+     * Log a FATAL level message
+     * @param body - Log message
+     * @param attributes - Optional structured attributes
+     * @param context - Optional trace context
+     */
+    fatal(body, attributes, context) {
+        this.log(exports.LogSeverity.FATAL, 'FATAL', body, attributes, context);
+    }
+}
+
 exports.APP_CONFIG = APP_CONFIG;
 exports.AUTH0_CONFIG = AUTH0_CONFIG;
 exports.AuthService = AuthService;
 exports.EventBus = EventBus;
+exports.Logger = Logger;
 exports.STORAGE_CONFIG = STORAGE_CONFIG;
 exports.STORAGE_KEYS = STORAGE_KEYS;
 exports.configureAuth0 = configureAuth0;