wingify-fme-ruby-sdk 1.50.0

data/lib/wingify/packages/storage/connector.rb

@@ -0,0 +1,26 @@
+# 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.
+
+class Connector
+    # Define an abstract method for setting data
+    def set(_key, _data)
+      raise NotImplementedError, "#{self.class} must implement the `set` method"
+    end
+  
+    # Define an abstract method for getting data
+    def get(_key)
+      raise NotImplementedError, "#{self.class} must implement the `get` method"
+    end
+  end
+  

data/lib/wingify/packages/storage/storage.rb

@@ -0,0 +1,47 @@
+# 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 'connector' # Import Connector class
+
+class Storage
+  @instance = nil
+
+  attr_reader :connector
+  attr_accessor :is_storage_enabled
+
+  def initialize
+    @connector = nil
+    @is_storage_enabled = false
+  end
+
+  # Attach a connector (can be an instance or a class)
+  def attach_connector(connector)
+    if connector.is_a?(Class) # Check if it's a class before instantiating
+      @connector = connector.new
+    else
+      @connector = connector
+    end
+    @connector
+  end
+
+  # Singleton instance method
+  def self.instance
+    @instance ||= new
+  end
+
+  # Get the attached connector
+  def get_connector
+    @connector
+  end
+end

data/lib/wingify/services/batch_event_queue.rb

@@ -0,0 +1,179 @@
+# 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 '../utils/data_type_util'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../constants/constants'
+require_relative '../packages/network_layer/manager/network_manager'
+require 'concurrent'
+
+class BatchEventsQueue
+    class << self
+        def instance
+          @instance ||= nil
+        end
+    
+        def configure(batch_config)
+          @instance = new(batch_config)
+        end
+    end
+    # Initializes a new batch events queue with the specified configuration
+    # @param batch_config Configuration object containing:
+    #   - request_time_interval: Time interval between batch requests (in seconds)
+    #   - events_per_request: Maximum number of events to include in a single request
+    #   - flush_callback: Callback function to execute after flushing events
+    #   - dispatcher: Function to handle sending the batched events
+    def initialize(batch_config)
+      @queue = []
+      @batch_config = batch_config
+      @network_client = NetworkManager.instance.get_client
+  
+      if DataTypeUtil.is_number(batch_config[:request_time_interval]) && batch_config[:request_time_interval] >= 1
+        @request_time_interval = batch_config[:request_time_interval]
+      else
+        @request_time_interval = Constants::DEFAULT_REQUEST_TIME_INTERVAL
+        LoggerService.log(LogLevelEnum::INFO, "EVENT_BATCH_DEFAULTS", {
+          parameter: 'request_time_interval',
+          minLimit: 0,
+          defaultValue: "#{@request_time_interval} seconds"
+        })
+      end
+  
+      if DataTypeUtil.is_number(batch_config[:events_per_request]) && 
+         batch_config[:events_per_request] > 0 && 
+         batch_config[:events_per_request] <= Constants::MAX_EVENTS_PER_REQUEST
+        @events_per_request = batch_config[:events_per_request]
+      elsif DataTypeUtil.is_number(batch_config[:events_per_request]) && 
+            batch_config[:events_per_request] > Constants::MAX_EVENTS_PER_REQUEST
+        @events_per_request = Constants::MAX_EVENTS_PER_REQUEST
+        LoggerService.log(LogLevelEnum::INFO, "EVENT_BATCH_MAX_LIMIT", {
+          parameter: 'events_per_request',
+          maxLimit: Constants::MAX_EVENTS_PER_REQUEST.to_s
+        })
+      else
+        @events_per_request = Constants::DEFAULT_EVENTS_PER_REQUEST
+        LoggerService.log(LogLevelEnum::INFO, "EVENT_BATCH_DEFAULTS", {
+          parameter: 'events_per_request',
+          minLimit: 0,
+          defaultValue: @events_per_request.to_s
+        })
+      end
+  
+      @flush_callback = batch_config[:flush_callback] if batch_config[:flush_callback].respond_to?(:call)
+  
+      @dispatcher = batch_config[:dispatcher]
+      @batch_lock = Mutex.new
+      @timer = nil
+      create_new_batch_timer
+    end
+  
+    # Creates a new timer thread to automatically flush events after request_time_interval
+    # The timer is only created if one doesn't already exist
+    def create_new_batch_timer
+      return if @timer
+  
+      @timer = Time.now + @request_time_interval
+      @thread = Thread.new { flush_when_request_times_up }
+    end
+  
+    # Adds a new event to the queue and manages batch processing
+    # If queue reaches events_per_request limit, it triggers an immediate flush
+    # @param event The event to be added to the queue
+    def enqueue(event)
+      @queue.push(event)
+  
+      LoggerService.log(LogLevelEnum::INFO, "EVENT_QUEUE", {
+        queueType: 'batch',
+        event: event.to_json
+      })
+
+      # if the number of events in the queue is equal to the events_per_request, flush
+      if @queue.length >= @events_per_request
+        flush
+      end
+    end
+  
+    # Background thread function that monitors the timer
+    # When the timer expires, it flushes the queue and cleans up
+    def flush_when_request_times_up
+      sleep(1) while @timer && Time.now < @timer
+      flush
+    end
+  
+    # Processes and sends all queued events
+    # @param manual Boolean indicating if flush was triggered manually
+    # Clears the queue after successful processing
+    def flush(manual = false)
+      @batch_lock.synchronize do
+        if @queue.any?
+          LoggerService.log(LogLevelEnum::DEBUG, "EVENT_BATCH_BEFORE_FLUSHING", {
+            manually: manual ? 'manually' : '',
+            length: @queue.length,
+            accountId: @batch_config[:account_id],
+            timer: manual ? 'Timer will be cleared and registered again' : ''
+          })
+  
+          # add events to another queue
+          temp_queue = @queue.dup
+          @queue = []
+          
+          if manual
+            future = Concurrent::Future.new(executor: @network_client.get_thread_pool) do
+              handle_flush_response(temp_queue, manual)
+            end
+            future.execute
+            @response = future.value
+          else
+            @network_client.get_thread_pool.post do
+              handle_flush_response(temp_queue, manual)
+            end
+          end
+        else
+          LoggerService.log(LogLevelEnum::DEBUG, "BATCH_QUEUE_EMPTY")
+          @response = {status: "success", events: []}
+        end
+        kill_old_thread if !manual && @thread
+        clear_request_timer
+        create_new_batch_timer
+        @response
+      end
+    end
+  
+    private
+
+    def handle_flush_response(temp_queue, manual)
+      @response = @dispatcher.call(temp_queue, @flush_callback)
+      if @response[:status] == "success"
+        LoggerService.log(LogLevelEnum::INFO, "EVENT_BATCH_After_FLUSHING", {
+          manually: manual ? 'manually' : '',
+          length: temp_queue.length
+        })
+      else
+        @queue.concat(temp_queue)
+      end
+      temp_queue = []
+      @response
+    end
+
+    # Resets the request timer to nil
+    def clear_request_timer
+      @timer = nil
+    end
+
+    def kill_old_thread
+      @old_thread&.kill
+    end
+end
+  

data/lib/wingify/services/campaign_decision_service.rb

@@ -0,0 +1,161 @@
+# 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 '../packages/decision_maker/decision_maker'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../packages/segmentation_evaluator/core/segmentation_manager'
+
+require_relative '../constants/constants'
+require_relative '../models/campaign/variation_model'
+require_relative '../models/campaign/campaign_model'
+require_relative '../models/user/context_model'
+require_relative '../enums/campaign_type_enum'
+require_relative '../utils/data_type_util'
+require_relative '../utils/log_message_util'
+
+class CampaignDecisionService
+  # Determines if a user is part of a campaign based on bucketing logic
+  # @param user_id [String] The ID of the user
+  # @param campaign [CampaignModel] The campaign to check
+  # @return [Boolean] True if the user is part of the campaign, false otherwise
+  def is_user_part_of_campaign(context, campaign)
+    return false if campaign.nil? || context.nil?
+
+    user_id = context.get_id
+    bucketing_seed = context.get_bucketing_seed
+    bucketing_id = bucketing_seed || user_id
+
+    is_rollout_or_personalize = [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign.get_type)
+    salt = is_rollout_or_personalize ? campaign.get_variations.first.get_salt : campaign.get_salt
+    traffic_allocation = is_rollout_or_personalize ? campaign.get_variations.first.get_weight : campaign.get_traffic
+
+    bucket_key = salt ? "#{salt}_#{bucketing_id}" : "#{campaign.get_id}_#{bucketing_id}"
+    value_assigned_to_user = DecisionMaker.new.get_bucket_value_for_user(bucket_key)
+
+    is_user_part = value_assigned_to_user != 0 && value_assigned_to_user <= traffic_allocation
+
+    LoggerService.log(LogLevelEnum::INFO, "USER_PART_OF_CAMPAIGN", {
+      userId: bucketing_id != user_id ? "#{user_id} (Seed: #{bucketing_id})" : user_id,
+      notPart: is_user_part ? '' : 'not',
+      campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}"
+    })
+
+    is_user_part
+  end
+
+  # Returns the variation assigned to a user based on bucket value
+  # @param variations [Array<VariationModel>] The variations to check
+  # @param bucket_value [Integer] The bucket value to check
+  # @return [VariationModel] The variation assigned to the user
+  def get_variation(variations, bucket_value)
+    variations.find { |variation| bucket_value >= variation.get_start_range_variation && bucket_value <= variation.get_end_range_variation }
+  end
+
+  # Checks if the bucket value is in the range of the variation
+  # @param variation [VariationModel] The variation to check
+  # @param bucket_value [Integer] The bucket value to check
+  # @return [VariationModel] The variation if the bucket value is in the range, nil otherwise
+  def check_in_range(variation, bucket_value)
+    variation if bucket_value >= variation.get_start_range_variation && bucket_value <= variation.get_end_range_variation
+  end
+
+  # Buckets a user into a variation for a given campaign
+  # @param user_id [String] The ID of the user
+  # @param account_id [String] The ID of the account
+  # @param campaign [CampaignModel] The campaign to bucket the user into
+  # @return [VariationModel] The variation assigned to the user
+  def bucket_user_to_variation(context, account_id, campaign)
+    return nil if campaign.nil? || context.nil?
+
+    user_id = context.get_id
+    bucketing_seed = context.get_bucketing_seed
+    bucketing_id = bucketing_seed || user_id
+
+    multiplier = campaign.get_traffic ? 1 : nil
+    percent_traffic = campaign.get_traffic
+    salt = campaign.get_salt
+    bucket_key = salt ? "#{salt}_#{account_id}_#{bucketing_id}" : "#{campaign.get_id}_#{account_id}_#{bucketing_id}"
+
+    hash_value = DecisionMaker.new.generate_hash_value(bucket_key)
+    bucket_value = DecisionMaker.new.generate_bucket_value(hash_value, Constants::MAX_TRAFFIC_VALUE, multiplier)
+
+    LoggerService.log(LogLevelEnum::DEBUG, "USER_BUCKET_TO_VARIATION", {
+      userId: bucketing_id != user_id ? "#{user_id} (Seed: #{bucketing_id})" : user_id,
+      campaignKey: campaign.get_key,
+      percentTraffic: percent_traffic,
+      bucketValue: bucket_value,
+      hashValue: hash_value
+    })
+
+    get_variation(campaign.get_variations, bucket_value)
+  end
+
+  # Pre-segmentation decision based on user context and campaign rules
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  # @return [Boolean] True if the user satisfies the campaign rules, false otherwise
+  def get_pre_segmentation_decision(campaign, context)
+    campaign_type = campaign.get_type
+    segments = if [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign_type)
+                 campaign.get_variations.first.get_segments
+               elsif campaign_type == CampaignTypeEnum::AB
+                 campaign.get_segments
+               end
+
+    if DataTypeUtil.is_object(segments) && segments.empty?
+      LoggerService.log(LogLevelEnum::INFO, "SEGMENTATION_SKIP", {
+        userId: context.get_id,
+        campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}"
+      })
+      return true
+    else
+      pre_segmentation_result = SegmentationManager.instance.validate_segmentation(segments, context.get_custom_variables)
+
+      if !pre_segmentation_result
+        LoggerService.log(LogLevelEnum::INFO, "SEGMENTATION_STATUS", {
+          userId: context.get_id,
+          campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+          status: 'failed'
+        })
+        return false
+      end
+
+      LoggerService.log(LogLevelEnum::INFO, "SEGMENTATION_STATUS", {
+        userId: context.get_id,
+        campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+        status: 'passed'
+      })
+
+      return true
+    end
+  end
+
+  # Determines the variation assigned to a user for a campaign
+  # @param user_id [String] The ID of the user
+  # @param account_id [String] The ID of the account
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @return [VariationModel] The variation assigned to the user
+  def get_variation_alloted(context, account_id, campaign)
+    is_user_part = is_user_part_of_campaign(context, campaign)
+
+    if [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign.get_type)
+      return campaign.get_variations.first if is_user_part
+    else
+      return bucket_user_to_variation(context, account_id, campaign) if is_user_part
+    end
+
+    nil
+  end
+end

data/lib/wingify/services/hooks_service.rb

@@ -0,0 +1,51 @@
+# 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 '../models/vwo_options_model'
+require_relative '../utils/data_type_util'
+
+class HooksService
+  attr_reader :decision
+
+  def initialize(options)
+    @callback = options.dig(:integrations, :callback)
+    @is_callback_function = is_function?(@callback)
+    @decision = {}
+  end
+
+  # Executes the callback
+  # @param properties [Hash] Properties from the callback
+  def execute(properties)
+    @callback.call(properties) if @is_callback_function
+  end
+
+  # Sets properties to the decision object
+  # @param properties [Hash] Properties to set
+  def set(properties)
+    @decision = properties if @is_callback_function
+  end
+
+  # Retrieves the decision object
+  # @return [Hash] The decision object
+  def get
+    @decision
+  end
+
+  private
+
+  # Helper function to check if a value is a function (assumed from data_type_util.rb)
+  def is_function?(val)
+    val.respond_to?(:call)
+  end
+end

data/lib/wingify/services/logger_service.rb

@@ -0,0 +1,114 @@
+# 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_relative '../wingify_client'
+require_relative '../packages/logger/core/log_manager'
+require_relative '../enums/log_level_enum'
+require_relative '../utils/log_message_util'
+require_relative '../enums/debug_category_enum'
+require_relative '../utils/debugger_service_util'
+require_relative '../utils/brand_context'
+require_relative '../utils/brand_util'
+
+class LoggerService
+  class << self
+    attr_accessor :debug_messages, :info_messages, :error_messages, :warning_messages
+  end
+
+  def self.log(level, key = nil, map = {}, should_send_to_vwo = true)
+    is_via_vwo = BrandContext.is_via_vwo?
+    log_manager = LogManager.instance({ prefix: BrandUtil.get_log_prefix(is_via_vwo) })
+
+    if key && map
+      message = build_message(get_messages(level)[key], map)
+    else
+      message = key # key acts as the message when no map is provided
+    end
+
+    case level
+    when LogLevelEnum::DEBUG
+      log_manager.debug(message)
+    when LogLevelEnum::INFO
+      log_manager.info(message)
+    when LogLevelEnum::WARN
+      log_manager.warn(message)
+    else
+      log_manager.error(message)
+      if should_send_to_vwo
+        # print log
+        self.send_log_to_vwo(key, message, map)
+      end
+    end
+  end
+
+  def initialize(config = {})
+    is_via_vwo = BrandContext.is_via_vwo?
+    config[:prefix] ||= BrandUtil.get_log_prefix(is_via_vwo)
+
+    # Initialize the LogManager
+    LogManager.instance(config)
+
+    # Read the log files and set class variables
+    self.class.debug_messages = read_and_stamp_log_files('debug_messages.json', is_via_vwo)
+    self.class.info_messages = read_and_stamp_log_files('info_messages.json', is_via_vwo)
+    self.class.error_messages = read_and_stamp_log_files('error_messages.json', is_via_vwo)
+    self.class.warning_messages = read_and_stamp_log_files('warn_messages.json', is_via_vwo)
+  end
+
+  private
+
+  def read_and_stamp_log_files(file_name, is_via_vwo)
+    begin
+      # Use absolute path resolution from the project root
+      file_path = File.join(File.expand_path('../../resources', __dir__), file_name)
+      raw = JSON.parse(File.read(file_path))
+      brand = BrandUtil.get_brand_name(is_via_vwo)
+      log_prefix = BrandUtil.get_log_prefix(is_via_vwo)
+      raw.transform_values do |msg|
+        msg.gsub('{brand}', brand).gsub('{log_prefix}', log_prefix)
+      end
+    rescue StandardError => e
+      puts "Error reading log file #{file_name}: #{e.message}"
+      return {}
+    end
+  end
+
+  def self.get_messages(level)
+    case level
+    when LogLevelEnum::DEBUG
+      @debug_messages
+    when LogLevelEnum::INFO
+      @info_messages
+    when LogLevelEnum::WARN
+      @warning_messages
+    else
+      @error_messages
+    end
+  end
+
+  def self.send_log_to_vwo(template, message, debug_props = {})
+    # send debugger event to VWO
+    begin
+      debug_props[:msg_t] = template
+      debug_props[:msg] = message
+      debug_props[:lt] = LogLevelEnum::ERROR
+      debug_props[:cg] = DebugCategoryEnum::ERROR
+
+      DebuggerServiceUtil.send_debugger_event(debug_props)
+    rescue StandardError => e
+      puts "[#{BrandUtil.get_log_prefix(BrandContext.is_via_vwo?)}] ERROR: Error sending log to VWO: #{e.message}"
+    end
+  end
+end