vwo-fme-ruby-sdk 1.0.0 → 1.1.0

data/lib/vwo/packages/decision_maker/decision_maker.rb

@@ -0,0 +1,60 @@
+# Copyright 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.
+
+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/vwo/packages/logger/core/log_manager.rb

@@ -0,0 +1,90 @@
+# Copyright 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'
+
+class LogManager < Logger
+    @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)
+      @transport_manager.log('ERROR', message)
+    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]))
+      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/vwo/packages/logger/core/transport_manager.rb

@@ -0,0 +1,87 @@
+# Copyright 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.
+
+require_relative '../log_message_builder'
+
+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 = log_level_to_number(transport_level)
+      desired_level = log_level_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
+  
+    private
+  
+    def log_level_to_number(level)
+      {
+        'TRACE' => 0,
+        'DEBUG' => 1,
+        'INFO' => 2,
+        'WARN' => 3,
+        'ERROR' => 4
+      }[level.upcase] || 0
+    end
+  end
+  
+  

data/lib/vwo/packages/logger/log_message_builder.rb

@@ -0,0 +1,70 @@
+# Copyright 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.
+
+class LogMessageBuilder
+    ANSI_COLOR_ENUM = {
+      bold: "\x1b[1m",
+      cyan: "\x1b[36m",
+      green: "\x1b[32m",
+      lightblue: "\x1b[94m",
+      red: "\x1b[31m",
+      reset: "\x1b[0m",
+      white: "\x1b[30m",
+      yellow: "\x1b[33m"
+    }
+  
+    LOG_LEVEL_COLOR = {
+      'TRACE' => ANSI_COLOR_ENUM[:white],
+      'DEBUG' => ANSI_COLOR_ENUM[:lightblue],
+      'INFO' => ANSI_COLOR_ENUM[:cyan],
+      'WARN' => ANSI_COLOR_ENUM[:yellow],
+      'ERROR' => ANSI_COLOR_ENUM[:red]
+    }
+  
+    def initialize(logger_config, transport_config)
+      @logger_config = logger_config
+      @transport_config = transport_config
+  
+      # Access the values directly from transport_config if available.
+      @prefix = transport_config.instance_variable_get(:@prefix) || logger_config[:prefix] || ''
+      @date_time_format = transport_config.respond_to?(:date_time_format) ? transport_config.date_time_format : logger_config[:date_time_format] || lambda { Time.now.iso8601 }
+    end
+  
+    def format_message(level, message)
+      "[#{get_formatted_level(level)}]: #{get_formatted_prefix(@prefix)} #{get_formatted_date_time} #{message}"
+    end
+  
+    private
+  
+    def get_formatted_prefix(prefix)
+      if @logger_config[:is_ansi_color_enabled]
+        "#{ANSI_COLOR_ENUM[:bold]}#{ANSI_COLOR_ENUM[:green]}#{prefix}#{ANSI_COLOR_ENUM[:reset]}"
+      else
+        prefix
+      end
+    end
+  
+    def get_formatted_level(level)
+      color = LOG_LEVEL_COLOR[level.upcase] || ''
+      level_string = level.upcase
+      return "#{color}#{level_string}#{ANSI_COLOR_ENUM[:reset]}" if @logger_config[:is_ansi_color_enabled]
+  
+      level_string
+    end
+  
+    def get_formatted_date_time
+      @date_time_format.call
+    end
+  end
+  

data/lib/vwo/packages/logger/logger.rb

@@ -0,0 +1,38 @@
+# Copyright 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.
+
+# logger.rb
+class Logger
+    # Abstract method definitions for logging at different levels
+    def trace(message)
+      raise NotImplementedError, "You must implement the trace method"
+    end
+  
+    def debug(message)
+      raise NotImplementedError, "You must implement the debug method"
+    end
+  
+    def info(message)
+      raise NotImplementedError, "You must implement the info method"
+    end
+  
+    def warn(message)
+      raise NotImplementedError, "You must implement the warn method"
+    end
+  
+    def error(message)
+      raise NotImplementedError, "You must implement the error method"
+    end
+  end
+  

data/lib/vwo/packages/logger/transports/console_transport.rb

@@ -0,0 +1,49 @@
+# Copyright 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.
+
+class ConsoleTransport
+    attr_reader :level, :prefix
+  
+    def initialize(config = {})
+      @config = config
+      @level = @config[:level] || 'ERROR'
+      @prefix = @config[:prefix] || 'VWO-SDK'  # Ensure `@prefix` is set here
+    end
+  
+    # Define the logging methods
+    def trace(message)
+      console_log('TRACE', message)
+    end
+  
+    def debug(message)
+      console_log('DEBUG', message)
+    end
+  
+    def info(message)
+      console_log('INFO', message)
+    end
+  
+    def warn(message)
+      console_log('WARN', message)
+    end
+  
+    def error(message)
+      console_log('ERROR', message)
+    end
+  
+    def console_log(level, message)
+      puts "#{message}" # Output the log to console
+    end
+  end
+  

data/lib/vwo/packages/network_layer/client/network_client.rb

@@ -0,0 +1,107 @@
+# Copyright 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.
+
+require 'json'
+require 'uri'
+require_relative '../models/request_model'
+require_relative '../models/response_model'
+require_relative '../../../utils/network_util'
+require 'net/http'
+require 'concurrent-ruby'
+require_relative '../../../constants/constants'
+
+class NetworkClient
+  HTTPS_SCHEME = 'https'
+
+  def initialize(options = {})
+    # options for threading
+    @should_use_threading = options.key?(:enabled) ? options[:enabled] : Constants::SHOULD_USE_THREADING
+    @thread_pool = Concurrent::FixedThreadPool.new(options.key?(:max_pool_size) ? options[:max_pool_size] : Constants::MAX_POOL_SIZE)
+  end
+
+  def get_thread_pool
+    @thread_pool
+  end
+
+  def get(request_model)
+    # Build the URL and headers
+    url = request_model.get_url + request_model.get_path
+    uri = URI(url)
+    
+    # Create the HTTP GET request
+    request = Net::HTTP::Get.new(uri)
+    # Add headers to the request
+    request_model.get_headers.each { |k, v| request[k] = v }
+  
+    # Send the GET request and get the response
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      http.request(request)
+    end
+  
+    # Process the response
+    response_model = ResponseModel.new
+    response_model.set_status_code(response.code.to_i)  # Convert status code to integer
+    
+    begin
+      # Parse the response body as JSON
+      parsed_data = JSON.parse(response.body)
+      response_model.set_data(parsed_data)
+    rescue StandardError => e
+      # Handle any JSON parsing errors
+      response_model.set_error(e.message)
+    end
+  
+    # Return the response model
+    response_model
+  end
+
+  def post(request_model)
+    def execute_post(request_model)
+      url = request_model.get_url + request_model.get_path
+      uri = URI(url)
+      headers = request_model.get_headers  # Directly use the hash from the request model
+      body = JSON.dump(request_model.get_body)
+  
+      request = Net::HTTP::Post.new(uri, headers)  # Pass the hash of headers directly
+      request.body = body
+  
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') { |http| http.request(request) }
+  
+      response_model = ResponseModel.new
+      response_model.set_status_code(response.code.to_i)
+
+      # Check if the response body is empty or invalid before parsing
+      if response.is_a?(Net::HTTPSuccess) && !response.body.strip.empty?
+        begin
+          parsed_data = JSON.parse(response.body)
+          response_model.set_data(parsed_data)
+        rescue JSON::ParserError => e
+          # Handle invalid JSON response
+          response_model.set_error("Invalid JSON response: #{e.message}")
+        end
+      else
+      end
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "POST request failed: #{e.message}", nil)
+    end
+
+    # Check if threading is enabled in options
+    if @should_use_threading
+      @thread_pool.post { execute_post(request_model) }
+    else
+      execute_post(request_model)
+    end
+  end
+  
+end

data/lib/vwo/packages/network_layer/handlers/request_handler.rb

@@ -0,0 +1,37 @@
+# Copyright 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.
+
+require_relative '../models/global_request_model'
+require_relative '../models/request_model'
+
+class RequestHandler
+  def create_request(request, config)
+    return nil if config.get_base_url.nil? && request.get_url.nil?
+
+    request.set_url(request.get_url || config.get_base_url)
+    request.set_timeout(request.get_timeout || config.get_timeout)
+    request.set_body(request.get_body || config.get_body)
+    request.set_headers(request.get_headers || config.get_headers)
+
+    request_query_params = request.get_query || {}
+    config_query_params = config.get_query || {}
+
+    config_query_params.each do |key, value|
+      request_query_params[key] ||= value
+    end
+
+    request.set_query(request_query_params)
+    request
+  end
+end

data/lib/vwo/packages/network_layer/manager/network_manager.rb

@@ -0,0 +1,78 @@
+# Copyright 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.
+
+require_relative '../client/network_client'
+require_relative '../handlers/request_handler'
+require_relative '../models/global_request_model'
+require_relative '../../../services/logger_service'
+require_relative '../../../enums/log_level_enum'
+require_relative '../../../constants/constants'
+class NetworkManager
+  @instance = nil
+
+  def initialize(options = {})
+    @client = NetworkClient.new(options)
+    @config = GlobalRequestModel.new(nil, {}, {}, {})
+    @should_use_threading = options.key?(:enabled) ? options[:enabled] : Constants::SHOULD_USE_THREADING
+  end
+
+  def self.instance(options = {})
+    @instance ||= new(options)
+  end
+
+  def attach_client(client = nil)
+    @client = client || NetworkClient.new(@should_use_threading)
+  end
+
+  def get_client
+    @client
+  end
+
+  def set_config(config)
+    @config = config
+  end
+
+  def get_config
+    @config
+  end
+
+  def create_request(request)
+    RequestHandler.new.create_request(request, @config)
+  end
+
+  def get(request)
+    begin
+      network_options = create_request(request)
+      raise 'No URL found' if network_options.get_url.nil?
+  
+      response = @client.get(network_options)
+      response
+    rescue => e
+      LoggerService.log(LogLevelEnum::ERROR, "Error getting: #{e.message}", nil)
+      raise e
+    end
+  end
+  
+
+  def post(request)
+    begin
+      network_options = create_request(request)
+      raise 'No URL found' if network_options.get_url.nil?
+
+      @client.post(network_options)
+    rescue => e
+      LoggerService.log(LogLevelEnum::ERROR, "Error posting: #{e.message}", nil)
+    end
+  end  
+end