wingify-fme-ruby-sdk 1.50.0

data/lib/wingify/utils/usage_stats_util.rb

@@ -0,0 +1,119 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# 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
+#
+#    http://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.
+
+
+require_relative '../constants/constants'
+require_relative '../enums/log_level_to_number'
+
+# Manages usage statistics for the SDK.
+# Tracks various features and configurations being used by the client.
+# Implements Singleton pattern to ensure a single instance.
+class UsageStatsUtil
+  @instance = nil
+  @usage_stats_data = {}
+
+  class << self
+    # Provides access to the singleton instance of UsageStatsUtil.
+    #
+    # @return [UsageStatsUtil] The single instance of UsageStatsUtil
+    def instance
+      @instance ||= new
+    end
+
+    # Sets usage statistics based on provided options.
+    # Maps various SDK features and configurations to boolean flags.
+    #
+    # @param options [Hash] Configuration options for the SDK
+    def set_usage_stats(options)
+      instance.set_usage_stats(options)
+    end
+
+    # Retrieves the current usage statistics.
+    #
+    # @return [Hash] Record containing boolean flags for various SDK features in use
+    def get_usage_stats
+      instance.get_usage_stats
+    end
+
+    def clear_usage_stats
+      instance.clear_usage_stats
+    end
+  end
+
+  private_class_method :new
+
+  def initialize
+    @usage_stats_data = {}
+  end
+
+  def set_usage_stats(options)
+    storage = options[:storage]
+    logger = options[:logger]
+    event_batching = options[:batch_event_data]
+    integrations = options[:integrations]
+    poll_interval = options[:poll_interval]
+    vwo_meta = options[:_vwo_meta]
+    gateway_service = options[:gateway_service]
+    threading = options[:threading]
+
+    data = {}
+
+    data[:a] = SettingsService.instance.account_id
+    data[:env] = SettingsService.instance.sdk_key
+    data[:ig] = 1 if integrations
+    data[:eb] = 1 if event_batching
+    data[:gs] = 1 if gateway_service
+
+    # if logger has transport or transports, then it is custom logger
+    if logger && (logger.key?(:transport) || logger.key?(:transports))
+      data[:cl] = 1
+    end
+
+    data[:ss] = 1 if storage
+
+    if logger && logger.key?(:level)
+      data[:ll] = LogLevelToNumber.to_number(logger[:level]) || -1
+    end
+
+    data[:pi] = poll_interval if poll_interval
+
+    if vwo_meta && vwo_meta.key?(:ea)
+      data[:_ea] = 1
+    end
+
+    # check if threading is not passed or is if passed then enabled should be true
+    if !threading || (threading && threading[:enabled] == true)
+      data[:th] = 1
+      # check if max_pool_size is passed
+      if threading && threading[:max_pool_size]
+        data[:th_mps] = threading[:max_pool_size]
+      end
+    end
+
+    if defined?(RUBY_VERSION)
+      data[:lv] = RUBY_VERSION
+    end
+
+    @usage_stats_data = data
+  end
+
+  def get_usage_stats
+    @usage_stats_data
+  end
+
+  def clear_usage_stats
+    @usage_stats_data = {}
+  end
+end
+

data/lib/wingify/utils/uuid_util.rb

@@ -0,0 +1,96 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# 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
+#
+#    http://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.
+
+require 'uuidtools'
+require 'securerandom'
+require_relative '../constants/constants'
+
+class UUIDUtil
+  # Generates a random UUID based on an API key.
+  #
+  # @param sdk_key [String] The API key used to generate a namespace for the UUID.
+  # @return [String] A random UUID string.
+  def self.get_random_uuid(sdk_key)
+    namespace = UUIDTools::UUID.sha1_create(UUIDTools::UUID_DNS_NAMESPACE, sdk_key)
+    random_uuid = UUIDTools::UUID.sha1_create(namespace, SecureRandom.uuid)
+    random_uuid.to_s
+  end
+
+  # Generates a UUID for a user based on their user_id and account_id.
+  #
+  # @param user_id [String] The user's ID.
+  # @param account_id [String] The account ID associated with the user.
+  # @return [String] A UUID string formatted without dashes and in uppercase.
+  def self.get_uuid(user_id, account_id)
+    vwo_namespace = UUIDTools::UUID.sha1_create(UUIDTools::UUID_URL_NAMESPACE, Constants::SEED_URL)
+    user_id_namespace = generate_uuid(account_id, vwo_namespace)
+    uuid_for_user_id_account_id = generate_uuid(user_id, user_id_namespace)
+
+    uuid_for_user_id_account_id.to_s.delete('-').upcase
+  end
+
+  # Helper function to generate a UUID v5 based on a name and a namespace.
+  #
+  # @param name [String] The name from which to generate the UUID.
+  # @param namespace [UUIDTools::UUID] The namespace used to generate the UUID.
+  # @return [UUIDTools::UUID] A UUID string or nil if inputs are invalid.
+  def self.generate_uuid(name, namespace)
+    return nil if name.nil? || namespace.nil?
+    # Convert name to string to handle integer inputs
+    name_str = name.to_s
+    UUIDTools::UUID.sha1_create(namespace, name_str)
+  end
+
+  # Checks if the given ID is a valid Web UUID.
+  #
+  # @param id [String] The ID to check.
+  # @return [Boolean] True if the ID is a valid Web UUID, false otherwise.
+  def self.web_uuid?(id)
+    return false unless id.is_a?(String)
+
+    !!(id =~ Constants::WEB_UUID_REGEX)
+  end
+
+  # Generates a UUID for a user based on their user_id and account_id.
+  #
+  # @param settings [SettingsModel] The settings of the VWO client.
+  # @param context [Hash] The context of the user.
+  # @param api_name [String] The name of the API called.
+  # @return [String] A UUID string formatted without dashes and in uppercase.
+  def self.get_uuid_from_context(settings, context, api_name)
+    if settings.get_is_web_connectivity_enabled != false
+      # if web connectivity is enabled, check if context[:id] is a valid web UUID
+      if context && web_uuid?(context[:id])
+        # if context[:id] is a valid web UUID, set it as uuid
+        LoggerService.log(LogLevelEnum::DEBUG, "WEB_UUID_FOUND", {apiName: api_name, uuid: context[:id]})
+        return context[:id]
+      else
+        # if context[:useIdForWeb] is true and context[:id] is not a valid web UUID, throw error
+        if context && context[:useIdForWeb] == true
+          raise StandardError, 'UUID passed in context.id is not a valid UUID'
+        end
+        return get_uuid(
+          context[:id].to_s,
+          SettingsService.instance.account_id.to_s
+        )
+      end
+    else
+      # if web connectivity is disabled, fallback to server-side UUID derivation
+      return get_uuid(
+        context[:id].to_s,
+        SettingsService.instance.account_id.to_s
+      )
+    end
+  end
+end

data/lib/wingify/wingify_builder.rb

@@ -0,0 +1,261 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# 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
+#
+#    http://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.
+
+# require 'json'
+# require 'uri'
+require_relative './enums/log_level_enum'
+require_relative 'wingify_client'
+require_relative './services/settings_service'
+require_relative './packages/storage/storage'
+require_relative './packages/network_layer/manager/network_manager'
+require_relative './packages/segmentation_evaluator/core/segmentation_manager'
+require_relative './services/logger_service'
+require_relative './services/batch_event_queue'
+require_relative './utils/function_util'
+require_relative './constants/constants'
+require_relative './utils/usage_stats_util'
+require_relative './enums/api_enum'
+require_relative './utils/batch_event_dispatcher_util'
+
+class WingifyBuilder
+  attr_reader :settings, :storage, :log_manager, :is_settings_fetch_in_progress, :wingify_instance, :is_valid_poll_interval_passed_from_init
+
+  # Initialize the VWOBuilder with the given options
+  # @param options [Hash] The options for the VWOBuilder
+  def initialize(options)
+    @options = options
+    @settings = nil
+    @storage = nil
+    @log_manager = nil
+    @is_settings_fetch_in_progress = false
+    @is_valid_poll_interval_passed_from_init = false
+    @wingify_instance = nil
+  end
+
+  # Initializes the batch event processing system
+  # Validates batch event settings and configures the BatchEventsQueue
+  # Sets up event dispatcher and flushes any existing events
+  # @raise [StandardError] If batch event configuration is invalid
+  def init_batch
+    # if gateway service is configured, then do not initialize batch event queue
+    if SettingsService.instance.is_gateway_service_provided
+      LoggerService.log(LogLevelEnum::INFO, "GATEWAY_AND_BATCH_EVENTS_CONFIG_MISMATCH")
+      return self
+    end
+    begin
+      if @options.key?(:batch_event_data)
+        if @options[:batch_event_data].is_a?(Hash)
+          # Validate batch event parameters
+          events_per_request = @options[:batch_event_data][:events_per_request]
+          request_time_interval = @options[:batch_event_data][:request_time_interval]
+          
+          if (!events_per_request.is_a?(Numeric) || events_per_request <= 0) &&
+             (!request_time_interval.is_a?(Numeric) || request_time_interval <= 0)
+            LoggerService.log(LogLevelEnum::ERROR, "INVALID_BATCH_EVENTS_CONFIG", { an: ApiEnum::INIT})
+          end
+          
+          BatchEventsQueue.configure(
+            @options[:batch_event_data].merge(
+              {
+                account_id: @options[:account_id],
+                dispatcher: method(:dispatcher)
+              }
+            )
+          )
+          @batch_event_data = @options[:batch_event_data]
+        else
+          LoggerService.log(LogLevelEnum::ERROR, "INVALID_BATCH_EVENTS_CONFIG", { an: ApiEnum::INIT})
+        end
+      end
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "FAILED_TO_INITIALIZE_SERVICE", { service: 'Batch Event Queue', err: e.message, an: ApiEnum::INIT})
+    end
+  end
+
+  # Set the network manager
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_network_manager
+    begin
+      network_instance = NetworkManager.instance(@options[:threading] || {})
+      retry_config = @options[:retry_config]
+      client = (@options[:network] && @options[:network][:client]) ? @options[:network][:client] : nil
+      network_instance.attach_client(client, retry_config)
+      LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", {service: "Network Layer"})
+      network_instance.get_config.set_development_mode(@options[:is_development_mode]) if @options[:is_development_mode]
+      self
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "FAILED_TO_INITIALIZE_SERVICE", { service: 'Network Manager', err: e.message, an: ApiEnum::INIT})
+      self
+    end
+  end
+
+  # Set the segmentation manager
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_segmentation
+    SegmentationManager.instance.attach_evaluator(@options[:segmentation]) if @options[:segmentation]
+    LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", {service: "Segmentation Evaluator"})
+    self
+  end
+
+  # Fetch the settings from the server
+  # @param force [Boolean] Whether to force the fetch of settings
+  # @return [Hash] The settings
+  def fetch_settings(force = false)
+    return @settings if !force && @settings
+    
+    @is_settings_fetch_in_progress = true
+    settings = SettingsService.new(@options).get_settings()
+    @is_settings_fetch_in_progress = false
+    @settings = settings unless force
+    settings
+  end
+
+  # Get the settings from the server
+  # @param force [Boolean] Whether to force the fetch of settings
+  # @return [Hash] The settings
+  def get_settings(force = false)
+    return @settings if !force && @settings
+    
+    begin
+      fetch_settings(force)
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_FETCHING_SETTINGS", { err: e.message, an: ApiEnum::INIT})
+      {}
+    end
+  end
+
+  # Set the storage
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_storage
+    if @options[:storage]
+      @storage = Storage.instance.attach_connector(@options[:storage])
+      Storage.instance.is_storage_enabled = true
+    else
+      @storage = nil
+    end
+    LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", {service: "Storage"})
+    self
+  end
+
+  # Set the settings service
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_settings_service
+    @settings_service = SettingsService.new(@options)
+    self
+  end
+
+  # Set the logger
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_logger
+    begin
+      @log_manager = LoggerService.new(@options[:logger] || {})
+      LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", {service: "Logger"})
+    rescue => e
+      puts "Got error while setting logger: #{e.message}"
+    end
+    self
+  end
+
+  # Initialize the polling
+  # @return [VWOBuilder] The VWOBuilder instance
+  def init_polling
+    poll_interval = @options[:poll_interval]
+    
+    if poll_interval && poll_interval.is_a?(Numeric) && poll_interval >= 1000
+      # this is to check if the poll_interval passed in options is valid
+      @is_valid_poll_interval_passed_from_init = true
+      check_and_poll
+    elsif poll_interval
+      # only log error if poll_interval is present in options
+      LoggerService.log(LogLevelEnum::ERROR, "INVALID_POLLING_CONFIGURATION", {
+        key: 'poll_interval',
+        correctType: 'number >= 1000',
+        an: ApiEnum::INIT
+      })
+    end
+    self
+  end
+
+  # Build the WingifyClient instance
+  # @param settings [Hash] The settings for the client instance
+  # @return [WingifyClient] The client instance
+  def build(settings)
+    @wingify_instance = WingifyClient.new(settings, @options)
+    # if poll_interval is not present in options, set it to the pollInterval from settings
+    update_poll_interval_and_check_and_poll(settings)
+    @wingify_instance
+  end
+
+  def update_poll_interval_and_check_and_poll(settings, should_check_and_poll = true)
+    # only update the poll_interval if it poll_interval is not valid or not present in options
+    if !@is_valid_poll_interval_passed_from_init
+      @options[:poll_interval] = settings["pollInterval"] || Constants::POLLING_INTERVAL
+      LoggerService.log(LogLevelEnum::DEBUG, "USING_POLL_INTERVAL_FROM_SETTINGS", {
+        source: settings["pollInterval"] ? 'settings' : 'default',
+        pollInterval: @options[:poll_interval]
+      })
+    end
+    # should_check_and_poll will be true only when we are updating the poll_interval first time from self.build method
+    # if we are updating the poll_interval already running polling, we don't need to check and poll again
+    if should_check_and_poll && !@is_valid_poll_interval_passed_from_init
+      check_and_poll
+    end
+  end
+
+  # This method is used to check and poll the settings from the server
+  # @return [VWOBuilder] The VWOBuilder instance
+  def check_and_poll
+    @thread_pool = NetworkManager.instance.get_client.get_thread_pool
+    @thread_pool.post do
+      loop do
+        sleep(@options[:poll_interval]/ 1000.0)
+        begin
+          latest_settings = fetch_settings(true)
+          if latest_settings && latest_settings.to_json != @settings.to_json
+            @settings = latest_settings
+            LoggerService.log(LogLevelEnum::INFO, "POLLING_SET_SETTINGS")
+            @wingify_instance.update_settings(latest_settings.clone, false) if @wingify_instance
+            update_poll_interval_and_check_and_poll(latest_settings, false)
+          elsif latest_settings
+            LoggerService.log(LogLevelEnum::INFO, "POLLING_NO_CHANGE_IN_SETTINGS")
+          end
+        rescue StandardError => e
+          LoggerService.log(LogLevelEnum::ERROR, "ERROR_UPDATING_SETTINGS", { err: e.message, an: ApiEnum::INIT})
+        end
+      end
+    end
+  end
+
+  def dispatcher(events, callback)
+    BatchEventDispatcherUtil.dispatch(
+      {
+        ev: events
+      },
+      callback,
+      {
+        a: @options[:account_id],
+        env: @options[:sdk_key]
+      }
+    )
+  end
+
+  # Initialize the usage stats
+  # @return [VWOBuilder] The VWOBuilder instance
+  def init_usage_stats
+    return self if @options[:is_usage_stats_disabled]
+
+    UsageStatsUtil.set_usage_stats(@options)
+    self
+  end
+end

data/lib/wingify/wingify_client.rb

@@ -0,0 +1,227 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# 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
+#
+#    http://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.
+
+require_relative 'services/settings_service'
+require_relative 'models/user/context_model'
+require_relative 'api/get_flag'
+require_relative 'api/set_attribute'
+require_relative 'api/track_event'
+require_relative 'utils/settings_util'
+require_relative 'services/logger_service'
+require_relative 'enums/log_level_enum'
+require_relative 'utils/network_util'
+require_relative 'models/schemas/settings_schema_validation'
+require_relative 'services/batch_event_queue'
+require_relative 'enums/api_enum'
+require_relative 'utils/uuid_util'
+
+class WingifyClient
+  attr_accessor :settings, :original_settings
+  attr_reader :options
+
+  def initialize(settings, options)
+    @options = options
+    @settings = settings
+    @original_settings = settings.dup
+    
+    begin
+      set_settings_and_add_campaigns_to_rules(settings, self)
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_ADDING_CAMPAIGNS_TO_RULES", { err: e.message, an: ApiEnum::INIT})
+    end
+    LoggerService.log(LogLevelEnum::INFO, "CLIENT_INITIALIZED")
+    self
+  end
+
+  # Get the flag for a given feature key and context
+  # @param feature_key [String] The key of the feature to get the flag for
+  # @param context [Hash] The context of the user
+  # @return [GetFlagResponse] The flag for the given feature key and context
+  def get_flag(feature_key, context)
+    api_name = 'get_flag'
+    uuid = nil
+    session_id = nil
+
+    # check if sessionId is present in context and should be non null and non empty
+    if context.is_a?(Hash) && context.key?(:sessionId) && !context[:sessionId].nil? && !context[:sessionId].to_s.empty?
+      session_id = context[:sessionId].to_i
+    else
+      session_id = Time.now.to_i
+    end
+  
+    begin
+      hooks_service = HooksService.new(@options)
+      LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
+      unless context.is_a?(Hash)
+        raise TypeError, 'Invalid context'
+      end
+      unless context[:id].is_a?(String) && !context[:id].empty?
+        raise TypeError, 'Invalid context, id should be a non-empty string'
+      end
+      # make a copy of the context to avoid modifying the original context
+      context_copy = context.dup
+      uuid = UUIDUtil.get_uuid_from_context(@settings, context_copy, api_name)
+      # add the uuid to the context copy
+      context_copy[:uuid] = uuid
+
+      # Validate bucketingSeed: must be a non-empty, non-whitespace-only string
+      if context_copy.key?(:bucketingSeed)
+        seed = context_copy[:bucketingSeed]
+        if seed.nil? || seed.is_a?(Numeric) || seed.is_a?(Hash) || seed.is_a?(Array) || (seed.is_a?(String) && seed.strip.empty?)
+          LoggerService.log(LogLevelEnum::ERROR, "INVALID_BUCKETING_SEED", { apiName: api_name, type: seed.class.name })
+          context_copy.delete(:bucketingSeed)
+        end
+      end
+
+      unless feature_key.is_a?(String) && !feature_key.empty?
+        raise TypeError, 'feature_key should be a non-empty string'
+      end
+      unless SettingsService.instance.is_settings_valid
+        raise TypeError, 'Invalid Settings'
+      end
+      
+      context_model = ContextModel.new.model_from_dictionary(context_copy)
+      FlagApi.new.get(feature_key, @settings, context_model, hooks_service)
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "EXECUTION_FAILED", {apiName: api_name, err: e.message, an: ApiEnum::GET_FLAG})
+      GetFlagResponse.new(false, [], uuid, session_id)
+    end
+  end
+
+  # Track an event with given properties and context
+  # @param event_name [String] The name of the event to track
+  # @param context [Hash] The context of the user
+  # @param event_properties [Hash] The properties of the event
+  # @return [Hash] The result of the event tracking
+  def track_event(event_name, context, event_properties = {})
+    api_name = 'track_event'
+    
+    begin
+      hooks_service = HooksService.new(@options)
+      LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
+
+      unless context.is_a?(Hash) && context[:id].is_a?(String) && !context[:id].empty?
+        raise TypeError, 'Invalid context, id should be a non-empty string'
+      end
+      # make a copy of the context to avoid modifying the original context
+      context_copy = context.dup
+      context_copy[:uuid] = UUIDUtil.get_uuid_from_context(@settings, context_copy, api_name)
+
+      unless event_name.is_a?(String) && !event_name.empty?
+        raise TypeError, 'event_name should be a non-empty string'
+      end
+      unless event_properties.is_a?(Hash)
+        raise TypeError, 'event_properties should be a hash'
+      end
+      unless SettingsService.instance.is_settings_valid
+        raise TypeError, 'Invalid Settings'
+      end
+      
+      context_model = ContextModel.new.model_from_dictionary(context_copy)
+      TrackApi.new.track(@settings, event_name, context_model, event_properties, hooks_service)
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "EXECUTION_FAILED", {apiName: api_name, err: e.message, an: ApiEnum::TRACK_EVENT})
+      { event_name: false }
+    end
+  end
+
+  # Set attributes for a given context
+  # @param attributes [Hash] The attributes to set
+  # @param context [Hash] The context of the user
+  # @return [Hash] The result of the attribute setting
+  def set_attribute(attributes, context = nil)
+    api_name = 'set_attribute'
+    
+    begin
+      LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
+      unless context.is_a?(Hash)
+        raise TypeError, 'Invalid context'
+      end
+      unless context[:id].is_a?(String) && !context[:id].empty?
+        raise TypeError, 'Invalid context, id should be a non-empty string'
+      end
+      # make a copy of the context to avoid modifying the original context
+      context_copy = context.dup
+      context_copy[:uuid] = UUIDUtil.get_uuid_from_context(@settings, context_copy, api_name)
+
+      unless attributes.is_a?(Hash) && !attributes.empty?
+        raise TypeError, 'Attributes should be a hash with key-value pairs and non-empty'
+      end
+      unless SettingsService.instance.is_settings_valid
+        raise TypeError, 'Invalid Settings'
+      end
+      
+      context_model = ContextModel.new.model_from_dictionary(context_copy)
+      SetAttributeApi.new.set_attribute(attributes, context_model)
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "EXECUTION_FAILED", {apiName: api_name, err: e.message, an: ApiEnum::SET_ATTRIBUTE})
+    end
+  end
+
+  # Update the settings of the VWO client instance
+  # @param settings [Hash] The settings to update with (optional)
+  # @param is_via_webhook [Boolean] Whether the update is via webhook (default: true)
+  # @return [void]
+  def update_settings(settings = nil, is_via_webhook = true)
+    api_name = 'update_settings'
+    
+    begin
+      LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
+      
+      # Fetch settings from server or use provided settings if not empty
+      settings_to_update = if settings.nil? || settings.empty?
+        SettingsService.instance.fetch_settings(is_via_webhook)
+      else
+        settings
+      end
+
+      # Validate settings schema
+      unless SettingsSchema.new.is_settings_valid(settings_to_update)
+        raise TypeError, "Got Invalid Settings, settings: #{settings_to_update}"
+      end
+
+      # Set the settings on the client instance
+      set_settings_and_add_campaigns_to_rules(settings_to_update, self)
+      LoggerService.log(LogLevelEnum::INFO, "SETTINGS_UPDATED", {apiName: api_name, isViaWebhook: is_via_webhook})
+    rescue StandardError => e
+      LoggerService.log(
+        LogLevelEnum::ERROR,
+        "UPDATING_CLIENT_INSTANCE_FAILED_WHEN_WEBHOOK_TRIGGERED",
+        {
+          apiName: api_name,
+          isViaWebhook: is_via_webhook,
+          err: e.message,
+          an: ApiEnum::UPDATE_SETTINGS
+        }, false
+      )
+    end
+  end
+
+  # Flushes the batch events queue
+  # @return [void]
+  def flush_events
+    api_name = 'flush_events'
+    begin
+      LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
+      if BatchEventsQueue.instance.nil?
+        raise StandardError, "Batch events queue is not initialized"
+      end
+      # flush the batch events queue
+      @response = BatchEventsQueue.instance.flush(true)
+      @response
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "EXECUTION_FAILED", {apiName: api_name, err: e.message, an: ApiEnum::FLUSH_EVENTS})
+    end
+  end
+end