wingify-fme-ruby-sdk 1.50.0

data/lib/wingify/models/storage/storage_data_model.rb

@@ -0,0 +1,44 @@
+# 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 '../user/context_model'
+
+class StorageDataModel
+  attr_accessor :feature_key, :context, :rollout_id, :rollout_key, :rollout_variation_id,
+                :experiment_id, :experiment_key, :experiment_variation_id
+
+  def initialize
+    @feature_key = ''
+    @context = nil
+    @rollout_id = nil
+    @rollout_key = ''
+    @rollout_variation_id = nil
+    @experiment_id = nil
+    @experiment_key = ''
+    @experiment_variation_id = nil
+  end
+
+  # Creates a model instance from a hash (dictionary)
+  def model_from_dictionary(storage_data)
+    @feature_key = storage_data[:feature_key]
+    @context = storage_data[:context]
+    @rollout_id = storage_data[:rollout_id]
+    @rollout_key = storage_data[:rollout_key]
+    @rollout_variation_id = storage_data[:rollout_variation_id]
+    @experiment_id = storage_data[:experiment_id]
+    @experiment_key = storage_data[:experiment_key]
+    @experiment_variation_id = storage_data[:experiment_variation_id]
+    self
+  end
+end

data/lib/wingify/models/user/context_model.rb

@@ -0,0 +1,154 @@
+# 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 './context_vwo_model'
+require_relative '../../utils/uuid_util'
+require_relative '../../services/settings_service'
+
+class ContextModel
+  attr_accessor :id, :user_agent, :ip_address, :custom_variables, :variation_targeting_variables, :post_segmentation_variables, :vwo, :session_id, :uuid, :bucketing_seed
+
+  def initialize(id = nil, user_agent = nil, ip_address = nil, custom_variables = {}, variation_targeting_variables = {}, post_segmentation_variables = {}, vwo = nil, session_id = nil, uuid = nil, bucketing_seed = nil)
+    @id = id
+    @user_agent = user_agent
+    @ip_address = ip_address
+    @custom_variables = custom_variables || {}
+    @variation_targeting_variables = variation_targeting_variables || {}
+    @post_segmentation_variables = post_segmentation_variables || {}
+    @vwo = vwo
+    @session_id = session_id
+    @uuid = uuid
+    @bucketing_seed = bucketing_seed
+  end
+
+  # Creates a model instance from a hash (dictionary)
+  def model_from_dictionary(context)
+    if context.key?(:customVariables) && !context[:customVariables].is_a?(Hash)
+      raise TypeError, 'Invalid context, customVariables should be a hash'
+    end
+
+    if context.key?(:userAgent) && !context[:userAgent].is_a?(String)
+      raise TypeError, 'Invalid context, userAgent should be a string'
+    end
+
+    if context.key?(:ipAddress) && !context[:ipAddress].is_a?(String)
+      raise TypeError, 'Invalid context, ipAddress should be a string'
+    end
+
+    @id = context[:id]
+    @user_agent = context[:userAgent]
+    @ip_address = context[:ipAddress]
+    @custom_variables = context[:customVariables] if context.key?(:customVariables)
+    @variation_targeting_variables = context[:variationTargetingVariables] if context.key?(:variationTargetingVariables)
+    @post_segmentation_variables = context[:postSegmentationVariables] if context.key?(:postSegmentationVariables)
+    @vwo = ContextVWOModel.new.model_from_dictionary(context[:_vwo]) if context.key?(:_vwo)
+    @bucketing_seed = context[:bucketingSeed].to_s if context.key?(:bucketingSeed)
+
+    # check if sessionId is present in context and should be non null and non empty
+    if 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
+
+    # check if uuid is present in context and should be non null and non empty string
+    if context.key?(:uuid) && context[:uuid].is_a?(String) && !context[:uuid].empty?
+      @uuid = context[:uuid]
+    else
+      @uuid = UUIDUtil.get_uuid(id.to_s, SettingsService.instance.account_id.to_s)
+    end
+
+    self
+  end
+
+  def get_id
+    @id
+  end
+
+  def set_id(id)
+    @id = id
+  end
+
+  def get_user_agent
+    @user_agent
+  end
+
+  def set_user_agent(user_agent)
+    @user_agent = user_agent
+  end
+
+  def get_ip_address
+    @ip_address
+  end
+
+  def set_ip_address(ip_address)
+    @ip_address = ip_address
+  end
+
+  def get_custom_variables
+    @custom_variables
+  end
+
+  def set_custom_variables(custom_variables)
+    @custom_variables = custom_variables
+  end
+
+  def get_variation_targeting_variables
+    @variation_targeting_variables
+  end
+
+  def set_variation_targeting_variables(variation_targeting_variables)
+    @variation_targeting_variables = variation_targeting_variables
+  end
+
+  def get_post_segmentation_variables
+    @post_segmentation_variables
+  end
+
+  def set_post_segmentation_variables(post_segmentation_variables)
+    @post_segmentation_variables = post_segmentation_variables
+  end
+
+  def get_vwo
+    @vwo
+  end
+
+  def set_vwo(vwo)
+    @vwo = vwo
+  end
+
+  def get_session_id
+    @session_id
+  end
+
+  def set_session_id(session_id)
+    @session_id = session_id
+  end
+
+  def get_uuid
+    @uuid
+  end
+
+  def set_uuid(uuid)
+    @uuid = uuid
+  end
+
+  def get_bucketing_seed
+    @bucketing_seed
+  end
+
+  def set_bucketing_seed(bucketing_seed)
+    @bucketing_seed = bucketing_seed
+  end
+end

data/lib/wingify/models/user/context_vwo_model.rb

@@ -0,0 +1,38 @@
+# 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 ContextVWOModel
+    attr_accessor :location, :user_agent
+  
+    def initialize(location = {}, user_agent = {})
+      @location = location
+      @user_agent = user_agent
+    end
+  
+    # Creates a model instance from a hash (dictionary)
+    def model_from_dictionary(context)
+      @location = context["location"] if context.key?("location")
+      @user_agent = context["userAgent"] if context.key?("userAgent")
+      self
+    end
+
+    def get_location
+        @location
+    end
+
+    def get_ua_info
+        @user_agent
+    end
+  end
+  

data/lib/wingify/models/user/get_flag_response.rb

@@ -0,0 +1,50 @@
+# 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 GetFlagResponse
+  attr_reader :is_enabled, :get_variables, :get_variable, :get_uuid, :get_session_id
+  
+  def initialize(is_enabled, variables = [], uuid = nil, session_id = nil)
+    @is_enabled = is_enabled
+    @variables = variables
+    @uuid = uuid
+    @session_id = session_id
+  end
+  
+  # Define method for is_enabled
+  def is_enabled
+    @is_enabled
+  end
+
+  # Define method for get_variables
+  def get_variables
+    @variables
+  end
+
+  # Define method for get_variable
+  def get_variable(key, default_value = nil)
+      variable = @variables.find { |var| var.key == key }
+      variable ? variable.value : default_value
+  end
+
+  # Define method for get_uuid
+  def get_uuid
+    @uuid
+  end
+
+  # Define method for get_session_id
+  def get_session_id
+    @session_id
+  end
+end

data/lib/wingify/models/vwo_options_model.rb

@@ -0,0 +1,129 @@
+# 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 VWOOptionsModel
+  attr_accessor :account_id, :sdk_key, :is_development_mode, :storage, :gateway_service,
+                :poll_interval, :logger, :segmentation, :integrations, :network,
+                :should_wait_for_tracking_calls, :settings, :vwo_builder, :is_usage_stats_disabled, :_vwo_meta,
+                :retry_config, :proxy_url
+
+  def initialize(options = {})
+    @account_id = options[:account_id]
+    @sdk_key = options[:sdk_key]
+    @is_development_mode = options[:is_development_mode]
+    @storage = options[:storage]
+    @gateway_service = options[:gateway_service]
+    @poll_interval = options[:poll_interval]
+    @logger = options[:logger]
+    @segmentation = options[:segmentation]
+    @integrations = options[:integrations]
+    @network = options[:network]
+    @should_wait_for_tracking_calls = options[:should_wait_for_tracking_calls]
+    @settings = options[:settings]
+    @vwo_builder = options[:vwo_builder]
+    @is_usage_stats_disabled = options[:is_usage_stats_disabled]
+    @_vwo_meta = options[:_vwo_meta]
+    @retry_config = options[:retry_config]
+    @proxy_url = options[:proxy_url]
+  end
+
+  # Creates a model instance from a hash (dictionary)
+  def model_from_dictionary(options)
+    @account_id = options[:account_id]
+    @sdk_key = options[:sdk_key]
+    @vwo_builder = options[:vwo_builder]
+
+    @should_wait_for_tracking_calls = options[:should_wait_for_tracking_calls] if options.key?(:should_wait_for_tracking_calls)
+    @is_development_mode = options[:is_development_mode] if options.key?(:is_development_mode)
+    @storage = options[:storage] if options.key?(:storage)
+    @gateway_service = options[:gateway_service] if options.key?(:gateway_service)
+    @poll_interval = options[:poll_interval] if options.key?(:poll_interval)
+    @logger = options[:logger] if options.key?(:logger)
+    @segmentation = options[:segmentation] if options.key?(:segmentation)
+    @integrations = options[:integrations] if options.key?(:integrations)
+    @network = options[:network] if options.key?(:network)
+    @settings = options[:settings] if options.key?(:settings)
+    @retry_config = options[:retry_config] if options.key?(:retry_config)
+    @proxy_url = options[:proxy_url] if options.key?(:proxy_url)
+    self
+  end
+
+  def get_account_id
+    @account_id
+  end
+
+  def get_sdk_key
+    @sdk_key
+  end
+
+  def get_is_development_mode
+    @is_development_mode
+  end
+
+  def get_storage
+    @storage
+  end
+
+  def get_gateway_service
+    @gateway_service
+  end
+
+  def get_poll_interval
+    @poll_interval
+  end
+
+  def get_logger
+    @logger
+  end
+
+  def get_segmentation
+    @segmentation
+  end
+
+  def get_integrations
+    @integrations
+  end
+
+  def get_network
+    @network
+  end
+
+  def get_should_wait_for_tracking_calls
+    @should_wait_for_tracking_calls
+  end
+
+  def get_settings
+    @settings
+  end
+
+  def get_vwo_builder
+    @vwo_builder
+  end
+
+  def get_is_usage_stats_disabled
+    @is_usage_stats_disabled
+  end
+
+  def get_vwo_meta
+    @_vwo_meta
+  end
+
+  def get_retry_config
+    @retry_config
+  end
+
+  def get_proxy_url
+    @proxy_url
+  end
+end

data/lib/wingify/packages/decision_maker/decision_maker.rb

@@ -0,0 +1,60 @@
+# 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 'murmurhash3'
+
+class DecisionMaker
+  SEED_VALUE = 1 # Seed value for the hash function
+
+  # Generates a bucket value based on the hash value, maximum value, and an optional multiplier.
+  #
+  # @param hash_value [Integer] The hash value used for calculation.
+  # @param max_value [Integer] The maximum value for bucket scaling.
+  # @param multiplier [Integer] Optional multiplier to adjust the value (default: 1).
+  # @return [Integer] The calculated bucket value.
+  def generate_bucket_value(hash_value, max_value, multiplier = 1)
+    ratio = hash_value.to_f / (2**32)
+    multiplied_value = ((max_value * ratio) + 1) * multiplier
+    multiplied_value.floor
+  end
+
+  # Gets the bucket value for a user based on the hash key and maximum value.
+  #
+  # @param hash_key [String] The hash key for the user.
+  # @param max_value [Integer] The maximum value for bucket scaling (default: 100).
+  # @return [Integer] The calculated bucket value for the user.
+  def get_bucket_value_for_user(hash_key, max_value = 100)
+    hash_value = MurmurHash3::V32.str_hash(hash_key, SEED_VALUE)
+    generate_bucket_value(hash_value, max_value)
+  end
+
+  # Calculates the bucket value for a given string with an optional multiplier and maximum value.
+  #
+  # @param str [String] The input string to calculate the bucket value for.
+  # @param multiplier [Integer] Optional multiplier to adjust the value (default: 1).
+  # @param max_value [Integer] The maximum value for bucket scaling (default: 10000).
+  # @return [Integer] The calculated bucket value.
+  def calculate_bucket_value(str, multiplier = 1, max_value = 10000)
+    hash_value = generate_hash_value(str)
+    generate_bucket_value(hash_value, max_value, multiplier)
+  end
+
+  # Generates the hash value for a given hash key using MurmurHash v3.
+  #
+  # @param hash_key [String] The hash key for which the hash value is generated.
+  # @return [Integer] The generated hash value.
+  def generate_hash_value(hash_key)
+    MurmurHash3::V32.str_hash(hash_key, SEED_VALUE)
+  end
+end

data/lib/wingify/packages/logger/core/log_manager.rb

@@ -0,0 +1,92 @@
+# Copyright 2024-2025 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.
+
+# log_manager.rb
+require 'securerandom'
+require_relative '../logger'
+require_relative 'transport_manager'
+require_relative '../transports/console_transport'
+require_relative '../../../enums/log_level_enum'
+
+class LogManager < VWOLogger
+    @instance = nil
+
+    # Use the `instance` method to initialize and get the instance
+    def self.instance(config = {})
+        # If an instance already exists, return it
+        if @instance.nil?
+        @instance = new(config)
+        end
+        @instance
+    end
+  
+    def initialize(config = {})
+      # Store the config in an instance variable
+      @config = config
+  
+      # Initialize default config values inside @config
+      @config[:name] ||= 'VWO Logger'
+      @config[:request_id] ||= SecureRandom.uuid
+      @config[:level] ||= 'ERROR'
+      @config[:prefix] ||= 'VWO-SDK'
+      @config[:date_time_format] ||= lambda { Time.now.iso8601 }
+  
+      # Initialize the transport manager with the @config hash
+      @transport_manager = LogTransportManager.new(@config)
+      handle_transports
+    end
+  
+    def trace(message)
+      @transport_manager.log('TRACE', message)
+    end
+  
+    def debug(message)
+      @transport_manager.log('DEBUG', message)
+    end
+  
+    def info(message)
+      @transport_manager.log('INFO', message)
+    end
+  
+    def warn(message)
+      @transport_manager.log('WARN', message)
+    end
+  
+    def error(message, extraData = {})
+      @transport_manager.log('ERROR', message)
+      # sendLogToVWO(message, LogLevelEnum::ERROR, extraData)
+    end
+  
+    private
+  
+    def handle_transports
+      transports = @config[:transports] || []
+  
+      if transports.any?
+        add_transports(transports)
+      elsif @config[:transport]
+        add_transport(@config[:transport])
+      else
+        add_transport(ConsoleTransport.new(level: @config[:level], prefix: @config[:prefix]))
+      end
+    end
+  
+    def add_transport(transport)
+      @transport_manager.add_transport(transport)
+    end
+  
+    def add_transports(transports)
+      transports.each { |transport| add_transport(transport) }
+    end
+  end

data/lib/wingify/packages/logger/core/transport_manager.rb

@@ -0,0 +1,76 @@
+# 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 '../log_message_builder'
+require_relative '../../../enums/log_level_to_number'
+
+class LogTransportManager
+    def initialize(config)
+      @transports = []
+      @config = config # This should be the global config passed to LogManager
+    end
+  
+    def add_transport(transport)
+      @transports.push(transport)
+    end
+  
+    def should_log?(transport_level, config_level)
+      target_level = LogLevelToNumber.to_number(transport_level)
+      desired_level = LogLevelToNumber.to_number(config_level || @config[:level])
+      target_level >= desired_level
+    end
+  
+    def trace(message)
+      log('TRACE', message)
+    end
+  
+    def debug(message)
+      log('DEBUG', message)
+    end
+  
+    def info(message)
+      log('INFO', message)
+    end
+  
+    def warn(message)
+      log('WARN', message)
+    end
+  
+    def error(message)
+      log('ERROR', message)
+    end
+  
+    def log(level, message)
+      @transports.each do |transport|
+        # Pass the global config (from LogManager) to LogMessageBuilder, not the transport
+        log_message_builder = LogMessageBuilder.new(@config, transport)
+        formatted_message = log_message_builder.format_message(level, message)
+  
+        if should_log?(level, transport.level)
+          if transport.respond_to?(:log) && transport.method(:log).arity == 2
+            # Use custom log handler if available with correct arity
+            transport.log(level, message)
+          elsif transport.respond_to?(level.downcase.to_sym)
+            # Use level-specific method if available
+            transport.send(level.downcase.to_sym, formatted_message)
+          else
+            # Fallback to console_log
+            transport.console_log(level, formatted_message)
+          end
+        end
+      end
+    end
+  end
+  
+