[FSSDK-12298] client level attachment

Author: junaed-optimizely

src/client/createInstance.ts

@@ -16,8 +16,8 @@
 
 import { createInstance as jsCreateInstance } from '@optimizely/optimizely-sdk';
 import type { Config, Client } from '@optimizely/optimizely-sdk';
-import { getLoggerConfig } from '../logger/loggerConfigRegistry';
-import type { ReactLoggerConfig, ReactLogger } from '../logger/ReactLogger';
+import { REACT_LOGGER } from '../logger/createLogger';
+import type { ReactLogger } from '../logger/ReactLogger';
 
 export const CLIENT_ENGINE = 'react-sdk';
 export const CLIENT_VERSION = '4.0.0';
@@ -27,7 +27,6 @@ export const REACT_CLIENT_META = Symbol('react-client-meta');
 export interface ReactClientMeta {
   hasOdpManager: boolean;
   hasVuidManager: boolean;
-  loggerConfig?: ReactLoggerConfig;
   logger?: ReactLogger;
 }
 
@@ -41,6 +40,13 @@ export interface ReactClientMeta {
  * @returns An OptimizelyClient instance with React SDK metadata
  */
 export function createInstance(config: Config): Client {
+  let reactLogger: ReactLogger | undefined;
+
+  if (config.logger) {
+    reactLogger = (config.logger as Record<symbol, unknown>)[REACT_LOGGER] as ReactLogger | undefined;
+    delete (config.logger as Record<symbol, unknown>)[REACT_LOGGER];
+  }
+
   const jsClient = jsCreateInstance({
     ...config,
     clientEngine: CLIENT_ENGINE,
@@ -52,7 +58,7 @@ export function createInstance(config: Config): Client {
   reactClient[REACT_CLIENT_META] = {
     hasOdpManager: !!config.odpManager,
     hasVuidManager: !!config.vuidManager,
-    loggerConfig: config.logger ? getLoggerConfig(config.logger) : undefined,
+    logger: reactLogger,
   } satisfies ReactClientMeta;
 
   return reactClient;

src/index.ts

@@ -24,7 +24,7 @@ export {
   createVuidManager,
   createErrorNotifier,
 } from './client/index';
-export { createLogger } from './logger/index';
+export { createLogger, DEBUG, ERROR, WARN, INFO } from './logger/index';
 
 export type * from '@optimizely/optimizely-sdk';
 

src/logger/ReactLogger.ts

@@ -29,8 +29,7 @@ export interface ReactLoggerConfig {
   logHandler?: LogHandler;
 }
 
-const LOG_PREFIX = '[ReactSDK]';
-
+const LOG_PREFIX = '[OPTIMIZELY - REACT]';
 const defaultLogHandler: LogHandler = {
   log(level: LogLevel, message: string): void {
     switch (level) {
@@ -56,16 +55,16 @@ export function createReactLogger(config: ReactLoggerConfig): ReactLogger {
 
   return {
     debug: (msg) => {
-      if (level <= LogLevel.Debug) handler.log(LogLevel.Debug, `${LOG_PREFIX} ${msg}`);
+      if (level <= LogLevel.Debug) handler.log(LogLevel.Debug, `${LOG_PREFIX} - DEBUG ${msg}`);
     },
     info: (msg) => {
-      if (level <= LogLevel.Info) handler.log(LogLevel.Info, `${LOG_PREFIX} ${msg}`);
+      if (level <= LogLevel.Info) handler.log(LogLevel.Info, `${LOG_PREFIX} - INFO ${msg}`);
     },
     warn: (msg) => {
-      if (level <= LogLevel.Warn) handler.log(LogLevel.Warn, `${LOG_PREFIX} ${msg}`);
+      if (level <= LogLevel.Warn) handler.log(LogLevel.Warn, `${LOG_PREFIX} - WARN ${msg}`);
     },
     error: (msg) => {
-      if (level <= LogLevel.Error) handler.log(LogLevel.Error, `${LOG_PREFIX} ${msg}`);
+      if (level <= LogLevel.Error) handler.log(LogLevel.Error, `${LOG_PREFIX} - ERROR ${msg}`);
     },
   };
 }

src/logger/createLogger.spec.ts

@@ -16,10 +16,9 @@
 
 import { vi, describe, it, expect, beforeEach } from 'vitest';
 import { DEBUG, INFO, WARN, ERROR, LogLevel } from '@optimizely/optimizely-sdk';
-import type { LoggerConfig, LogHandler } from '@optimizely/optimizely-sdk';
-import { storeLoggerConfig, getLoggerConfig } from './loggerConfigRegistry';
+import type { LogHandler } from '@optimizely/optimizely-sdk';
 import { createReactLogger } from './ReactLogger';
-import type { ReactLoggerConfig } from './ReactLogger';
+import type { ReactLogger } from './ReactLogger';
 
 const mockOpaqueLogger = vi.hoisted(() => ({ __opaque: true }));
 
@@ -31,66 +30,57 @@ vi.mock('@optimizely/optimizely-sdk', async (importOriginal) => {
   };
 });
 
-import { createLogger } from './createLogger';
+import { createLogger, REACT_LOGGER } from './createLogger';
 
 describe('createLogger', () => {
   beforeEach(() => {
     vi.clearAllMocks();
   });
 
   it('should return the opaque logger from the JS SDK', () => {
-    const config: LoggerConfig = { level: INFO };
-    const result = createLogger(config);
+    const result = createLogger({ level: INFO });
     expect(result).toBe(mockOpaqueLogger);
   });
 
-  it('should store the resolved config in the registry', () => {
+  it('should attach a ReactLogger via the REACT_LOGGER symbol', () => {
     const mockHandler: LogHandler = { log: vi.fn() };
-    createLogger({ level: INFO, logHandler: mockHandler });
-
-    const storedConfig = getLoggerConfig(mockOpaqueLogger);
-    expect(storedConfig).toBeDefined();
-    expect(storedConfig!.logLevel).toBe(LogLevel.Info);
-    expect(storedConfig!.logHandler).toBe(mockHandler);
+    const result = createLogger({ level: INFO, logHandler: mockHandler });
+
+    const reactLogger = (result as Record<symbol, unknown>)[REACT_LOGGER] as ReactLogger;
+    expect(reactLogger).toBeDefined();
+    expect(reactLogger.debug).toBeTypeOf('function');
+    expect(reactLogger.info).toBeTypeOf('function');
+    expect(reactLogger.warn).toBeTypeOf('function');
+    expect(reactLogger.error).toBeTypeOf('function');
   });
 
-  describe('log level resolution', () => {
-    it.each([
-      { preset: DEBUG, expected: LogLevel.Debug, name: 'DEBUG' },
-      { preset: INFO, expected: LogLevel.Info, name: 'INFO' },
-      { preset: WARN, expected: LogLevel.Warn, name: 'WARN' },
-      { preset: ERROR, expected: LogLevel.Error, name: 'ERROR' },
-    ])('should resolve $name preset to LogLevel.$name', ({ preset, expected }) => {
-      createLogger({ level: preset });
-      const storedConfig = getLoggerConfig(mockOpaqueLogger);
-      expect(storedConfig!.logLevel).toBe(expected);
-    });
-  });
-});
+  it('should create a ReactLogger that uses the provided logHandler', () => {
+    const mockHandler: LogHandler = { log: vi.fn() };
+    const result = createLogger({ level: INFO, logHandler: mockHandler });
 
-describe('loggerConfigRegistry', () => {
-  it('should return undefined for unknown logger objects', () => {
-    expect(getLoggerConfig({})).toBeUndefined();
-  });
+    const reactLogger = (result as Record<symbol, unknown>)[REACT_LOGGER] as ReactLogger;
+    reactLogger.info('hello');
 
-  it('should store and retrieve config for a given logger', () => {
-    const logger = {};
-    const config: ReactLoggerConfig = { logLevel: LogLevel.Warn };
-    storeLoggerConfig(logger, config);
-    expect(getLoggerConfig(logger)).toBe(config);
+    expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Info, '[OPTIMIZELY - REACT] - INFO hello');
   });
 
-  it('should support multiple loggers with different configs', () => {
-    const logger1 = {};
-    const logger2 = {};
-    const config1: ReactLoggerConfig = { logLevel: LogLevel.Debug };
-    const config2: ReactLoggerConfig = { logLevel: LogLevel.Error };
-
-    storeLoggerConfig(logger1, config1);
-    storeLoggerConfig(logger2, config2);
-
-    expect(getLoggerConfig(logger1)).toBe(config1);
-    expect(getLoggerConfig(logger2)).toBe(config2);
+  describe('log level resolution', () => {
+    it.each([
+      { preset: DEBUG, expectedCalls: 4, name: 'DEBUG' },
+      { preset: INFO, expectedCalls: 3, name: 'INFO' },
+      { preset: WARN, expectedCalls: 2, name: 'WARN' },
+      { preset: ERROR, expectedCalls: 1, name: 'ERROR' },
+    ])('should resolve $name preset correctly', ({ preset, expectedCalls }) => {
+      const mockHandler: LogHandler = { log: vi.fn() };
+      const result = createLogger({ level: preset, logHandler: mockHandler });
+
+      const reactLogger = (result as Record<symbol, unknown>)[REACT_LOGGER] as ReactLogger;
+      reactLogger.debug('d');
+      reactLogger.info('i');
+      reactLogger.warn('w');
+      reactLogger.error('e');
+      expect(mockHandler.log).toHaveBeenCalledTimes(expectedCalls);
+    });
   });
 });
 
@@ -106,8 +96,8 @@ describe('createReactLogger', () => {
       logger.error('should appear');
 
       expect(mockHandler.log).toHaveBeenCalledTimes(2);
-      expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Warn, '[ReactSDK] should appear');
-      expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Error, '[ReactSDK] should appear');
+      expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Warn, '[OPTIMIZELY - REACT] - WARN should appear');
+      expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Error, '[OPTIMIZELY - REACT] - ERROR should appear');
     });
 
     it('should allow all messages when level is Debug', () => {
@@ -132,7 +122,7 @@ describe('createReactLogger', () => {
       logger.error('e');
 
       expect(mockHandler.log).toHaveBeenCalledTimes(1);
-      expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Error, '[ReactSDK] e');
+      expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Error, '[OPTIMIZELY - REACT] - ERROR e');
     });
   });
 
@@ -143,7 +133,7 @@ describe('createReactLogger', () => {
 
       logger.info('hello');
 
-      expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Info, '[ReactSDK] hello');
+      expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Info, '[OPTIMIZELY - REACT] - INFO hello');
     });
 
     it('should use default console handler when logHandler is not provided', () => {
@@ -152,13 +142,13 @@ describe('createReactLogger', () => {
 
       logger.info('hello');
 
-      expect(consoleSpy).toHaveBeenCalledWith('[ReactSDK] hello');
+      expect(consoleSpy).toHaveBeenCalledWith('[OPTIMIZELY - REACT] - INFO hello');
       consoleSpy.mockRestore();
     });
   });
 
   describe('message prefix', () => {
-    it('should prepend [ReactSDK] to all messages', () => {
+    it('should prepend [OPTIMIZELY - REACT] to all messages', () => {
       const mockHandler: LogHandler = { log: vi.fn() };
       const logger = createReactLogger({ logLevel: LogLevel.Debug, logHandler: mockHandler });
 
@@ -168,7 +158,7 @@ describe('createReactLogger', () => {
       logger.error('test');
 
       for (const call of (mockHandler.log as ReturnType<typeof vi.fn>).mock.calls) {
-        expect(call[1]).toMatch(/^\[ReactSDK\] /);
+        expect(call[1]).toMatch(/^\[OPTIMIZELY - REACT\] - (DEBUG|INFO|WARN|ERROR) /);
       }
     });
   });

src/logger/createLogger.ts

@@ -16,7 +16,9 @@
 
 import { createLogger as jsCreateLogger, LogLevel, DEBUG, INFO, WARN, ERROR } from '@optimizely/optimizely-sdk';
 import type { LoggerConfig, OpaqueLevelPreset } from '@optimizely/optimizely-sdk';
-import { storeLoggerConfig } from './loggerConfigRegistry';
+import { createReactLogger } from './ReactLogger';
+
+export const REACT_LOGGER = Symbol('react-logger');
 
 function resolveLogLevel(preset: OpaqueLevelPreset): LogLevel {
   if (preset === DEBUG) return LogLevel.Debug;
@@ -28,11 +30,10 @@ function resolveLogLevel(preset: OpaqueLevelPreset): LogLevel {
 
 export function createLogger(config: LoggerConfig) {
   const opaqueLogger = jsCreateLogger(config);
-
-  storeLoggerConfig(opaqueLogger, {
+  const reactLogger = createReactLogger({
     logLevel: resolveLogLevel(config.level),
     logHandler: config.logHandler,
   });
-
+  (opaqueLogger as Record<symbol, unknown>)[REACT_LOGGER] = reactLogger;
   return opaqueLogger;
 }

src/logger/getReactLogger.ts

@@ -17,23 +17,14 @@
 import type { Client } from '@optimizely/optimizely-sdk';
 import { REACT_CLIENT_META } from '../client/createInstance';
 import type { ReactClientMeta } from '../client/createInstance';
-import { createReactLogger } from './ReactLogger';
+import type { ReactLogger } from './ReactLogger';
 
 /**
- * Returns the cached ReactLogger instance for the given client.
- * Creates it lazily on first call; subsequent calls return the same instance.
- * Returns undefined if the client has no logger config (e.g., logger was
- * not created via the React SDK's createLogger wrapper).
+ * Returns the ReactLogger instance for the given client, or undefined
+ * if the client has no logger (e.g., logger was not created via the
+ * React SDK's createLogger wrapper).
  */
-export function getReactLogger(client: Client) {
+export function getReactLogger(client: Client): ReactLogger | undefined {
   const meta = (client as unknown as Record<symbol, ReactClientMeta>)[REACT_CLIENT_META];
-
-  if (meta.logger) return meta.logger;
-
-  if (meta.loggerConfig) {
-    meta.logger = createReactLogger(meta.loggerConfig);
-    return meta.logger;
-  }
-
-  return undefined;
+  return meta.logger;
 }

src/logger/index.ts

@@ -18,3 +18,4 @@ export { createLogger } from './createLogger';
 export { getReactLogger } from './getReactLogger';
 export { createReactLogger } from './ReactLogger';
 export type { ReactLogger, ReactLoggerConfig } from './ReactLogger';
+export { ERROR, DEBUG, WARN, INFO } from '@optimizely/optimizely-sdk';