[FSSDK-12298] singleton removal

Author: junaed-optimizely

src/client/createInstance.ts

@@ -16,6 +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';
 
 export const CLIENT_ENGINE = 'react-sdk';
 export const CLIENT_VERSION = '4.0.0';
@@ -25,6 +27,8 @@ export const REACT_CLIENT_META = Symbol('react-client-meta');
 export interface ReactClientMeta {
   hasOdpManager: boolean;
   hasVuidManager: boolean;
+  loggerConfig?: ReactLoggerConfig;
+  logger?: ReactLogger;
 }
 
 /**
@@ -48,6 +52,7 @@ export function createInstance(config: Config): Client {
   reactClient[REACT_CLIENT_META] = {
     hasOdpManager: !!config.odpManager,
     hasVuidManager: !!config.vuidManager,
+    loggerConfig: config.logger ? getLoggerConfig(config.logger) : undefined,
   } satisfies ReactClientMeta;
 
   return reactClient;

src/logger/createLogger.spec.ts

@@ -17,6 +17,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 { createReactLogger } from './ReactLogger';
+import type { ReactLoggerConfig } from './ReactLogger';
 
 const mockOpaqueLogger = vi.hoisted(() => ({ __opaque: true }));
 
@@ -28,7 +31,7 @@ vi.mock('@optimizely/optimizely-sdk', async (importOriginal) => {
   };
 });
 
-import { createLogger, getReactLogger } from './createLogger';
+import { createLogger } from './createLogger';
 
 describe('createLogger', () => {
   beforeEach(() => {
@@ -41,24 +44,62 @@ describe('createLogger', () => {
     expect(result).toBe(mockOpaqueLogger);
   });
 
-  it('should make the ReactLogger available via getReactLogger', () => {
-    const config: LoggerConfig = { level: INFO };
-    createLogger(config);
-
-    const reactLogger = getReactLogger();
-    expect(reactLogger).toBeDefined();
-    expect(typeof reactLogger!.debug).toBe('function');
-    expect(typeof reactLogger!.info).toBe('function');
-    expect(typeof reactLogger!.warn).toBe('function');
-    expect(typeof reactLogger!.error).toBe('function');
+  it('should store the resolved config in the registry', () => {
+    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);
+  });
+
+  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);
+    });
   });
+});
+
+describe('loggerConfigRegistry', () => {
+  it('should return undefined for unknown logger objects', () => {
+    expect(getLoggerConfig({})).toBeUndefined();
+  });
+
+  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);
+  });
+
+  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('createReactLogger', () => {
   describe('log level filtering', () => {
     it('should filter messages below the configured level', () => {
       const mockHandler: LogHandler = { log: vi.fn() };
-      createLogger({ level: WARN, logHandler: mockHandler });
+      const logger = createReactLogger({ logLevel: LogLevel.Warn, logHandler: mockHandler });
 
-      const logger = getReactLogger()!;
       logger.debug('should not appear');
       logger.info('should not appear');
       logger.warn('should appear');
@@ -69,11 +110,10 @@ describe('createLogger', () => {
       expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Error, '[ReactSDK] should appear');
     });
 
-    it('should allow all messages when level is DEBUG', () => {
+    it('should allow all messages when level is Debug', () => {
       const mockHandler: LogHandler = { log: vi.fn() };
-      createLogger({ level: DEBUG, logHandler: mockHandler });
+      const logger = createReactLogger({ logLevel: LogLevel.Debug, logHandler: mockHandler });
 
-      const logger = getReactLogger()!;
       logger.debug('d');
       logger.info('i');
       logger.warn('w');
@@ -82,11 +122,10 @@ describe('createLogger', () => {
       expect(mockHandler.log).toHaveBeenCalledTimes(4);
     });
 
-    it('should only allow error messages when level is ERROR', () => {
+    it('should only allow error messages when level is Error', () => {
       const mockHandler: LogHandler = { log: vi.fn() };
-      createLogger({ level: ERROR, logHandler: mockHandler });
+      const logger = createReactLogger({ logLevel: LogLevel.Error, logHandler: mockHandler });
 
-      const logger = getReactLogger()!;
       logger.debug('d');
       logger.info('i');
       logger.warn('w');
@@ -97,26 +136,40 @@ describe('createLogger', () => {
     });
   });
 
-  describe('custom log handler', () => {
+  describe('log handler', () => {
     it('should use the provided logHandler', () => {
       const mockHandler: LogHandler = { log: vi.fn() };
-      createLogger({ level: INFO, logHandler: mockHandler });
+      const logger = createReactLogger({ logLevel: LogLevel.Info, logHandler: mockHandler });
 
-      const logger = getReactLogger()!;
       logger.info('hello');
 
       expect(mockHandler.log).toHaveBeenCalledWith(LogLevel.Info, '[ReactSDK] hello');
     });
 
     it('should use default console handler when logHandler is not provided', () => {
       const consoleSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
-      createLogger({ level: INFO });
+      const logger = createReactLogger({ logLevel: LogLevel.Info });
 
-      const logger = getReactLogger()!;
       logger.info('hello');
 
       expect(consoleSpy).toHaveBeenCalledWith('[ReactSDK] hello');
       consoleSpy.mockRestore();
     });
   });
+
+  describe('message prefix', () => {
+    it('should prepend [ReactSDK] to all messages', () => {
+      const mockHandler: LogHandler = { log: vi.fn() };
+      const logger = createReactLogger({ logLevel: LogLevel.Debug, logHandler: mockHandler });
+
+      logger.debug('test');
+      logger.info('test');
+      logger.warn('test');
+      logger.error('test');
+
+      for (const call of (mockHandler.log as ReturnType<typeof vi.fn>).mock.calls) {
+        expect(call[1]).toMatch(/^\[ReactSDK\] /);
+      }
+    });
+  });
 });

src/logger/createLogger.ts

@@ -16,10 +16,7 @@
 
 import { createLogger as jsCreateLogger, LogLevel, DEBUG, INFO, WARN, ERROR } from '@optimizely/optimizely-sdk';
 import type { LoggerConfig, OpaqueLevelPreset } from '@optimizely/optimizely-sdk';
-import { createReactLogger } from './ReactLogger';
-import type { ReactLogger } from './ReactLogger';
-
-let reactLogger: ReactLogger | undefined;
+import { storeLoggerConfig } from './loggerConfigRegistry';
 
 function resolveLogLevel(preset: OpaqueLevelPreset): LogLevel {
   if (preset === DEBUG) return LogLevel.Debug;
@@ -32,14 +29,10 @@ function resolveLogLevel(preset: OpaqueLevelPreset): LogLevel {
 export function createLogger(config: LoggerConfig) {
   const opaqueLogger = jsCreateLogger(config);
 
-  reactLogger = createReactLogger({
+  storeLoggerConfig(opaqueLogger, {
     logLevel: resolveLogLevel(config.level),
     logHandler: config.logHandler,
   });
 
   return opaqueLogger;
 }
-
-export function getReactLogger(): ReactLogger | undefined {
-  return reactLogger;
-}

src/logger/getReactLogger.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2026, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { Client } from '@optimizely/optimizely-sdk';
+import { REACT_CLIENT_META } from '../client/createInstance';
+import type { ReactClientMeta } from '../client/createInstance';
+import { createReactLogger } 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).
+ */
+export function getReactLogger(client: Client) {
+  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;
+}

src/logger/index.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
-export { createLogger, getReactLogger } from './createLogger';
+export { createLogger } from './createLogger';
+export { getReactLogger } from './getReactLogger';
 export { createReactLogger } from './ReactLogger';
 export type { ReactLogger, ReactLoggerConfig } from './ReactLogger';

src/logger/loggerConfigRegistry.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2026, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { ReactLoggerConfig } from './ReactLogger';
+
+// WeakMap keyed by OpaqueLogger objects. Bridges the gap between
+// createLogger() and createInstance() — supports multiple clients with
+// different configs and automatically releases entries when the logger is GC'd.
+const registry = new WeakMap<object, ReactLoggerConfig>();
+
+export function storeLoggerConfig(logger: object, config: ReactLoggerConfig): void {
+  registry.set(logger, config);
+}
+
+export function getLoggerConfig(logger: object): ReactLoggerConfig | undefined {
+  return registry.get(logger);
+}

src/provider/OptimizelyProvider.tsx

@@ -19,7 +19,6 @@ import { NOTIFICATION_TYPES } from '@optimizely/optimizely-sdk';
 
 import { ProviderStateStore } from './ProviderStateStore';
 import { UserContextManager } from '../utils/UserContextManager';
-import { getReactLogger } from '../logger/index';
 import type { OptimizelyProviderProps, OptimizelyContextValue } from './types';
 import type { Client } from '@optimizely/optimizely-sdk';
 
@@ -75,7 +74,7 @@ export function OptimizelyProvider({
   // Readiness is derived from userContext + getOptimizelyConfig() by hooks.
   useEffect(() => {
     if (!client) {
-      getReactLogger()?.error('OptimizelyProvider must be passed an Optimizely client instance');
+      console.error('[ReactSDK] OptimizelyProvider must be passed an Optimizely client instance');
       store.setError(new Error('Optimizely client is required'));
       return;
     }