[FSSDK-11853] add swift logger support (#88)

* build: add Optimizely SDK logger classes

- Add FlutterOptimizelyLogger class implementing OPTLogger protocol
- Add constants for customLogger and loggerChannel
- Implement FlutterMethodChannel for invoking log method
- Add logger field to OptimizelyFlutterSdk constructor
- Initialize custom logger in OptimizelyClientWrapper
- Create LoggerBridge to handle log method calls
- Implement OptimizelyLogger interface and DefaultOptimizelyLogger class

* fix: resolve logging inconsistencies

- Update custom logger initialization in OptimizelyFlutterSdkPlugin
- Adjust logger channel setup in onDetachedFromEngine
- Refactor LoggerBridge to handle log calls from native Swift/Java code properly
- Ensure proper logging when no custom logger is set

* refactor: update logger imports

- Rename 'OptimizelyLogger.dart' to 'flutter_logger.dart'
- Rename 'LoggerBridge.dart' to 'logger_bridge.dart'
- Modify imports in 'optimizely_client_wrapper.dart' to reflect changes in logger files

* feat: add custom logger implementation

- Implement a custom logger class
- Define logLevel property with default debug level
- Define log method to print log messages with custom format

* refactor: rename logger classes in Android and iOS

- Rename FlutterOptimizelyLogger to OptimizelyFlutterLogger in Android
- Rename FlutterOptimizelyLogger to OptimizelyFlutterLogger in iOS

* feat: update logging behavior for Optimizely SDK

- Remove unused log level property in CustomLogger
- Implement channel setter method in OptimizelyFlutterLogger
- Add guard clauses for levels and logger channel availability in log method
- Update channel invocation to happen on main thread
- Set log level in SwiftOptimizelyFlutterSdkPlugin based on parameters
- Simplify DefaultOptimizelyLogger log method
- Update log message formatting in logger bridge for consistency

* feat: add methods and tests for logger state management

- Add methods to expose converting log level, checking if a custom logger is set, retrieving the current logger, and resetting the logger state
- Implement a method for simulating method calls
- Add tests for maintaining logger state across multiple operations
- Include a test for handling logger replacement
- Create tests for edge cases including handling empty messages and special characters

* feat: add separate logger channel for outgoing log calls

- Define LOGGER_CHANNEL constant for OptimizelyFlutterLogger class
- Set up separate FlutterMethodChannel for outgoing log calls
- Update SwiftOptimizelyFlutterSdkPlugin to use the new logger channel

* refactor: improve main thread dispatch for Flutter method channel calls

- Add DispatchQueue.main.async for each method call to ensure platform channel messages are sent on the correct thread

* chore: clean up logger implementation

- Remove unnecessary comments and TODOs
- Replace direct print statements with AppLogger methods
- Refactor AppLogger to enhance flexibility and ease of use

* style: update comment in sendLogToFlutter method

- Remove comparison to Swift's DispatchQueue.main.async

* chore: remove unused import statement

- Remove import statement for 'log_level' that is no longer used
- Update import paths for 'flutter_logger' and 'optimizely_flutter_sdk'

test: update test cases in logger_test.dart

- Update test cases to use 'const MethodCall' for creating method calls
- Change null and empty arguments to be created and handled correctly
- Fix missing level or message argument handling scenarios
- Improve handling of invalid level data types in method calls

docs: add comments to improve code clarity in logger_test.dart

- Add comments explaining the purpose of each test group and case
- Include comments for the different scenarios being tested in each case

* chore: update log messages and method channel handling

- Update log message format in CustomLogger class
- Refactor main thread dispatch logic for method channel calls in Utils.swift
- Enhance error handling and main thread dispatch in OptimizelyFlutterLogger.swift
- Modify method channel creation and task queue handling in SwiftOptimizelyFlutterSdkPlugin.swift

* refactor: enhance logging functionalities

- Replace usage of static AppLogger class with separate logging functions
- Introduce individual logger functions for error, warning, info, and debug levels
- Create a default stand-alone logger instance to handle logging operations

* test: add global logging functions test cases

- Test calling global logging functions without errors
- Test handling empty messages in global functions
- Test handling special characters in global functions
- Test handling rapid calls to global functions

* chore: remove custom logger functionality

- Remove code related to setting up and using a custom logger in OptimizelyFlutterClient.java
- Delete OptimizelyFlutterLogger.java file as it is no longer needed
- Update references to the logger channel in OptimizelyFlutterSdkPlugin.java

* refactor: rename customLogger to useCustomLogger

- Update 'Constants.swift' to change 'customLogger' to 'useCustomLogger'
- Update 'SwiftOptimizelyFlutterSdkPlugin.swift' to change 'customLogger' to 'useCustomLogger'
- Update 'optimizely_flutter_sdk.dart' to change 'logger' parameter to 'OptimizelyLogger'
- Update 'optimizely_client_wrapper.dart' to change 'customLogger' to 'useCustomLogger'
- Update 'constants.dart' to change 'customLogger' to 'useCustomLogger'

* clean up

Author: muzahidul-opti

android/src/main/java/com/optimizely/optimizely_flutter_sdk/OptimizelyFlutterClient.java

@@ -25,7 +25,6 @@
 import com.optimizely.ab.UnknownEventTypeException;
 import com.optimizely.ab.android.event_handler.DefaultEventHandler;
 import com.optimizely.ab.android.sdk.OptimizelyClient;
-
 import java.util.HashMap;
 import java.util.Map;
 
@@ -187,6 +186,7 @@ protected void initializeOptimizely(@NonNull ArgumentsParser argumentsParser, @N
         if (enableVuid) {
             optimizelyManagerBuilder.withVuidEnabled();
         }
+
         OptimizelyManager optimizelyManager = optimizelyManagerBuilder.build(context);
 
         optimizelyManager.initialize(context, null, (OptimizelyClient client) -> {

example/lib/custom_logger.dart

@@ -0,0 +1,11 @@
+import 'package:optimizely_flutter_sdk/optimizely_flutter_sdk.dart';
+import 'package:flutter/foundation.dart';
+
+class CustomLogger implements OptimizelyLogger {
+  @override
+  void log(OptimizelyLogLevel level, String message) {
+    if (kDebugMode) {
+      print('[OPTIMIZELY] ${level.name.toUpperCase()}: $message');
+    }
+  }
+}

example/lib/main.dart

@@ -2,6 +2,7 @@ import 'package:flutter/material.dart';
 import 'dart:async';
 import 'dart:math';
 import 'package:optimizely_flutter_sdk/optimizely_flutter_sdk.dart';
+import 'package:optimizely_flutter_sdk_example/custom_logger.dart';
 
 void main() {
   runApp(const MyApp());
@@ -28,16 +29,20 @@ class _MyAppState extends State<MyApp> {
       OptimizelyDecideOption.includeReasons,
       OptimizelyDecideOption.excludeVariables
     };
+    final customLogger = CustomLogger();
+
     var flutterSDK = OptimizelyFlutterSdk("X9mZd2WDywaUL9hZXyh9A",
         datafilePeriodicDownloadInterval: 10 * 60,
         eventOptions: const EventOptions(
             batchSize: 1, timeInterval: 60, maxQueueSize: 10000),
         defaultLogLevel: OptimizelyLogLevel.debug,
-        defaultDecideOptions: defaultOptions);
+        defaultDecideOptions: defaultOptions,
+        logger: customLogger,
+      );
     var response = await flutterSDK.initializeClient();
 
     setState(() {
-      uiResponse = "Optimizely Client initialized: ${response.success} ";
+      uiResponse = "[Optimizely] Client initialized: ${response.success} ";
     });
 
     var rng = Random();

ios/Classes/HelperClasses/Constants.swift

@@ -91,6 +91,7 @@ struct RequestParameterKey {
     static let reasons = "reasons"
     static let decideOptions = "optimizelyDecideOption"
     static let defaultLogLevel = "defaultLogLevel"
+    static let useCustomLogger = "useCustomLogger"
     static let eventBatchSize = "eventBatchSize"
     static let eventTimeInterval = "eventTimeInterval"
     static let eventMaxQueueSize = "eventMaxQueueSize"

ios/Classes/OptimizelyFlutterLogger.swift

@@ -0,0 +1,39 @@
+import Flutter
+import Optimizely
+
+public class OptimizelyFlutterLogger: NSObject, OPTLogger {
+    static var LOGGER_CHANNEL: String = "optimizely_flutter_sdk_logger";
+    
+    public static var logLevel: OptimizelyLogLevel = .info
+    
+    private static var loggerChannel: FlutterMethodChannel?
+    
+    public required override init() {
+        super.init()
+    }
+    
+    public static func setChannel(_ channel: FlutterMethodChannel) {
+        loggerChannel = channel
+    }
+    
+    public func log(level: OptimizelyLogLevel, message: String) {
+        // Early return if level check fails
+        guard level.rawValue <= OptimizelyFlutterLogger.logLevel.rawValue else { 
+            return 
+        }
+        
+        // Ensure we have a valid channel
+        guard let channel = Self.loggerChannel else {
+            print("[OptimizelyFlutterLogger] ERROR: No logger channel available!")
+            return
+        }
+        
+        // https://docs.flutter.dev/platform-integration/platform-channels#jumping-to-the-main-thread-in-ios
+        DispatchQueue.main.async {
+            channel.invokeMethod("log", arguments: [
+                "level": level.rawValue,
+                "message": message
+            ])
+        }
+    }
+}

ios/Classes/SwiftOptimizelyFlutterSdkPlugin.swift

@@ -41,6 +41,14 @@ public class SwiftOptimizelyFlutterSdkPlugin: NSObject, FlutterPlugin {
         channel = FlutterMethodChannel(name: "optimizely_flutter_sdk", binaryMessenger: registrar.messenger())
         let instance = SwiftOptimizelyFlutterSdkPlugin()
         registrar.addMethodCallDelegate(instance, channel: channel)
+
+        // Separate logger channel for outgoing log calls
+        let taskQueue = registrar.messenger().makeBackgroundTaskQueue?()
+        let loggerChannel = FlutterMethodChannel(name: OptimizelyFlutterLogger.LOGGER_CHANNEL, 
+                                                binaryMessenger: registrar.messenger(), 
+                                                codec: FlutterStandardMethodCodec.sharedInstance(),
+                                                taskQueue: taskQueue)
+        OptimizelyFlutterLogger.setChannel(loggerChannel)
     }
 
     /// Part of FlutterPlugin protocol to handle communication with flutter sdk
@@ -110,6 +118,7 @@ public class SwiftOptimizelyFlutterSdkPlugin: NSObject, FlutterPlugin {
         var defaultLogLevel = OptimizelyLogLevel.info
         if let logLevel = parameters[RequestParameterKey.defaultLogLevel] as? String {
             defaultLogLevel = Utils.getDefaultLogLevel(logLevel)
+            OptimizelyFlutterLogger.logLevel = defaultLogLevel
         }
 
         // SDK Settings Default Values
@@ -163,9 +172,19 @@ public class SwiftOptimizelyFlutterSdkPlugin: NSObject, FlutterPlugin {
         notificationIdsTracker.removeValue(forKey: sdkKey)
         optimizelyClientsTracker.removeValue(forKey: sdkKey)
 
+        // Check if custom logger is requested
+        var logger: OPTLogger?
+        if let useCustomLogger = parameters[RequestParameterKey.useCustomLogger] as? Bool, useCustomLogger {
+            // OptimizelyFlutterLogger bridges iOS logs to Flutter via Method Channel
+            // When useCustomLogger = true:
+            // iOS SDK log → OptimizelyFlutterLogger → Flutter Method Channel → Flutter console
+            logger = OptimizelyFlutterLogger()
+        }
+
         // Creating new instance
         let optimizelyInstance = OptimizelyClient(
             sdkKey:sdkKey, 
+            logger:logger,
             eventDispatcher: eventDispatcher, 
             datafileHandler: datafileHandler, 
             periodicDownloadInterval: datafilePeriodicDownloadInterval, 

lib/optimizely_flutter_sdk.dart

@@ -28,6 +28,8 @@ import 'package:optimizely_flutter_sdk/src/data_objects/optimizely_config_respon
 import 'package:optimizely_flutter_sdk/src/optimizely_client_wrapper.dart';
 import 'package:optimizely_flutter_sdk/src/user_context/optimizely_user_context.dart';
 import 'package:optimizely_flutter_sdk/src/data_objects/log_level.dart';
+import 'package:optimizely_flutter_sdk/src/logger/flutter_logger.dart';
+import 'package:optimizely_flutter_sdk/src/logger/logger_bridge.dart';
 
 export 'package:optimizely_flutter_sdk/src/optimizely_client_wrapper.dart'
     show ClientPlatform, ListenerType;
@@ -53,6 +55,8 @@ export 'package:optimizely_flutter_sdk/src/data_objects/datafile_options.dart'
     show DatafileHostOptions;
 export 'package:optimizely_flutter_sdk/src/data_objects/log_level.dart'
     show OptimizelyLogLevel;
+export 'package:optimizely_flutter_sdk/src/logger/flutter_logger.dart'
+    show OptimizelyLogger;
 
 /// The main client class for the Optimizely Flutter SDK.
 ///
@@ -68,20 +72,37 @@ class OptimizelyFlutterSdk {
   final Set<OptimizelyDecideOption> _defaultDecideOptions;
   final OptimizelyLogLevel _defaultLogLevel;
   final SDKSettings _sdkSettings;
+  static OptimizelyLogger? _customLogger;
+  /// Set a custom logger for the SDK
+  static void setLogger(OptimizelyLogger logger) {
+    _customLogger = logger;
+    LoggerBridge.initialize(logger);
+  }
+  /// Get the current logger
+  static OptimizelyLogger? get logger {
+    return _customLogger;
+  }
   OptimizelyFlutterSdk(this._sdkKey,
-      {EventOptions eventOptions = const EventOptions(),
-      int datafilePeriodicDownloadInterval =
-          10 * 60, // Default time interval in seconds
-      Map<ClientPlatform, DatafileHostOptions> datafileHostOptions = const {},
-      Set<OptimizelyDecideOption> defaultDecideOptions = const {},
-      OptimizelyLogLevel defaultLogLevel = OptimizelyLogLevel.info,
-      SDKSettings sdkSettings = const SDKSettings()})
-      : _eventOptions = eventOptions,
-        _datafilePeriodicDownloadInterval = datafilePeriodicDownloadInterval,
-        _datafileHostOptions = datafileHostOptions,
-        _defaultDecideOptions = defaultDecideOptions,
-        _defaultLogLevel = defaultLogLevel,
-        _sdkSettings = sdkSettings;
+    {EventOptions eventOptions = const EventOptions(),
+    int datafilePeriodicDownloadInterval = 10 * 60,
+    Map<ClientPlatform, DatafileHostOptions> datafileHostOptions = const {},
+    Set<OptimizelyDecideOption> defaultDecideOptions = const {},
+    OptimizelyLogLevel defaultLogLevel = OptimizelyLogLevel.info,
+    SDKSettings sdkSettings = const SDKSettings(),
+    OptimizelyLogger? logger}) 
+    : _eventOptions = eventOptions,
+      _datafilePeriodicDownloadInterval = datafilePeriodicDownloadInterval,
+      _datafileHostOptions = datafileHostOptions,
+      _defaultDecideOptions = defaultDecideOptions,
+      _defaultLogLevel = defaultLogLevel,
+      _sdkSettings = sdkSettings {
+      // Set the logger if provided
+      if (logger != null) {
+        setLogger(logger);
+      } else {
+        logWarning("Logger not provided.");
+      }
+  }
 
   /// Starts Optimizely SDK (Synchronous) with provided sdkKey.
   Future<BaseResponse> initializeClient() async {
@@ -92,7 +113,9 @@ class OptimizelyFlutterSdk {
         _datafileHostOptions,
         _defaultDecideOptions,
         _defaultLogLevel,
-        _sdkSettings);
+        _sdkSettings,
+        _customLogger
+    );
   }
 
   /// Use the activate method to start an experiment.

lib/src/logger/flutter_logger.dart

@@ -0,0 +1,26 @@
+import 'package:optimizely_flutter_sdk/src/data_objects/log_level.dart';
+
+abstract class OptimizelyLogger {
+  /// Log a message at a certain level
+  void log(OptimizelyLogLevel level, String message);
+}
+
+class DefaultOptimizelyLogger implements OptimizelyLogger {
+  @override
+  void log(OptimizelyLogLevel level, String message) {
+    print('[OPTIMIZELY] [${level.name.toUpperCase()}]: $message');
+  }
+}
+
+/// App logger instance
+final _appLogger = DefaultOptimizelyLogger();
+
+/// App logging functions
+void logError(String message) =>
+    _appLogger.log(OptimizelyLogLevel.error, message);
+void logWarning(String message) =>
+    _appLogger.log(OptimizelyLogLevel.warning, message);
+void logInfo(String message) =>
+    _appLogger.log(OptimizelyLogLevel.info, message);
+void logDebug(String message) =>
+    _appLogger.log(OptimizelyLogLevel.debug, message);

lib/src/logger/logger_bridge.dart

@@ -0,0 +1,98 @@
+import 'dart:async';
+import 'package:flutter/services.dart';
+import 'package:optimizely_flutter_sdk/src/logger/flutter_logger.dart';
+import 'package:optimizely_flutter_sdk/optimizely_flutter_sdk.dart';
+
+class LoggerBridge {
+  static const MethodChannel _loggerChannel =
+      MethodChannel('optimizely_flutter_sdk_logger');
+  static OptimizelyLogger? _customLogger;
+
+  /// Initialize the logger bridge to receive calls from native
+  static void initialize(OptimizelyLogger? logger) {
+    logInfo('[LoggerBridge] Initializing with logger: ${logger != null}');
+    _customLogger = logger;
+    _loggerChannel.setMethodCallHandler(_handleMethodCall);
+  }
+
+  /// Handle incoming method calls from native Swift/Java code
+  static Future<void> _handleMethodCall(MethodCall call) async {
+    try {
+      switch (call.method) {
+        case 'log':
+          await _handleLogCall(call);
+          break;
+        default:
+          logWarning('[LoggerBridge] Unknown method call: ${call.method}');
+      }
+    } catch (e) {
+      logError('[LoggerBridge] Error handling method call: $e');
+    }
+  }
+
+  /// Process the log call from Swift/Java
+  static Future<void> _handleLogCall(MethodCall call) async {
+    try {
+      final args = Map<String, dynamic>.from(call.arguments ?? {});
+
+      final levelRawValue = args['level'] as int?;
+      final message = args['message'] as String?;
+
+      if (levelRawValue == null || message == null) {
+        logError('[LoggerBridge] Warning: Missing level or message in log call');
+        return;
+      }
+
+      final level = _convertLogLevel(levelRawValue);
+
+      if (_customLogger != null) {
+        _customLogger!.log(level, message);
+      } else {
+        logInfo('[Optimizely ${level.name}] $message');
+      }
+    } catch (e) {
+      logError('[LoggerBridge] Error processing log call: $e');
+    }
+  }
+
+  /// Convert native log level to Flutter enum
+  static OptimizelyLogLevel _convertLogLevel(int rawValue) {
+    switch (rawValue) {
+      case 1:
+        return OptimizelyLogLevel.error;
+      case 2:
+        return OptimizelyLogLevel.warning;
+      case 3:
+        return OptimizelyLogLevel.info;
+      case 4:
+        return OptimizelyLogLevel.debug;
+      default:
+        return OptimizelyLogLevel.info;
+    }
+  }
+  
+  /// Expose convertLogLevel 
+  static OptimizelyLogLevel convertLogLevel(int rawValue) {
+    return _convertLogLevel(rawValue);
+  }
+
+  /// Check if a custom logger is set
+  static bool hasLogger() {
+    return _customLogger != null;
+  }
+
+  /// Get the current logger
+  static OptimizelyLogger? getCurrentLogger() {
+    return _customLogger;
+  }
+
+  /// Reset logger state
+  static void reset() {
+    _customLogger = null;
+  }
+
+  /// Simulate method calls
+  static Future<void> handleMethodCallForTesting(MethodCall call) async {
+    await _handleMethodCall(call);
+  }
+}

lib/src/optimizely_client_wrapper.dart

@@ -63,7 +63,8 @@ class OptimizelyClientWrapper {
       Map<ClientPlatform, DatafileHostOptions> datafileHostOptions,
       Set<OptimizelyDecideOption> defaultDecideOptions,
       OptimizelyLogLevel defaultLogLevel,
-      SDKSettings sdkSettings) async {
+      SDKSettings sdkSettings,
+      OptimizelyLogger? logger) async {
     _channel.setMethodCallHandler(methodCallHandler);
     final convertedOptions = Utils.convertDecideOptions(defaultDecideOptions);
     final convertedLogLevel = Utils.convertLogLevel(defaultLogLevel);
@@ -79,6 +80,7 @@ class OptimizelyClientWrapper {
       Constants.eventBatchSize: eventOptions.batchSize,
       Constants.eventTimeInterval: eventOptions.timeInterval,
       Constants.eventMaxQueueSize: eventOptions.maxQueueSize,
+      Constants.useCustomLogger: logger != null,
     };
 
     // Odp Request params