wingify-fme-ruby-sdk 1.50.0

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

@@ -0,0 +1,70 @@
+# 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 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/wingify/packages/logger/logger.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.
+
+# logger.rb
+class VWOLogger
+    # 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/wingify/packages/logger/transports/console_transport.rb

@@ -0,0 +1,49 @@
+# 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 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/wingify/packages/network_layer/client/network_client.rb

@@ -0,0 +1,276 @@
+# 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 '../models/request_model'
+require_relative '../models/response_model'
+require_relative '../../../utils/network_util'
+require 'net/http'
+require 'concurrent-ruby'
+require_relative '../../../constants/constants'
+require_relative '../../../services/logger_service'
+require_relative '../../../enums/log_level_enum'
+require_relative '../../../enums/event_enum'
+require_relative '../../../utils/function_util'
+
+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::ThreadPoolExecutor.new(
+      # Minimum number of threads to keep alive in the pool
+      min_threads: 1,
+      # Maximum number of threads allowed in the pool, configurable via options or defaults to MAX_POOL_SIZE constant
+      max_threads: options.key?(:max_pool_size) ? options[:max_pool_size] : Constants::MAX_POOL_SIZE,
+      # Maximum number of tasks that can be queued when all threads are busy
+      max_queue: options.key?(:max_queue_size) ? options[:max_queue_size] : Constants::MAX_QUEUE_SIZE,
+      # When queue is full, execute task in the caller's thread rather than rejecting it
+      fallback_policy: :caller_runs
+    )
+  end
+
+  def get_thread_pool
+    @thread_pool
+  end
+
+  def get_should_use_threading
+    @should_use_threading
+  end
+
+  def get(request_model)
+    execute_with_retry(request_model, :get_request)
+  end
+
+  def post(request_model)
+    execute_with_retry(request_model, :post_request)
+  end
+
+  private
+
+  def execute_with_retry(request_model, request_type)
+    url = request_model.get_url + request_model.get_path
+    uri = URI(url)
+    attempt = 0
+
+    # Get retry config from request model or use defaults
+    retry_config = request_model.get_retry_config || Constants::DEFAULT_RETRY_CONFIG.dup
+    extra_data = request_model.get_extra_info
+    endpoint = request_model.get_path.split('?')[0]
+    
+    # If retry is disabled, execute without retry logic
+    unless retry_config[:should_retry]
+      response_model, _should_retry, _last_error_message =
+        perform_single_attempt(uri, request_model, request_type, attempt, retry_config)
+      return response_model
+    end
+
+    # Attempt loop: initial attempt (0) + configured retries
+    last_error_message = nil
+    last_response_model = nil
+
+    (0..retry_config[:max_retries] - 1).each do |attempt_index|
+      attempt = attempt_index
+
+      # Perform a single attempt
+      response_model, should_retry, last_error_message =
+        perform_single_attempt(uri, request_model, request_type, attempt, retry_config, last_error_message)
+
+      last_response_model = response_model
+
+      # If there is no retry needed, return immediately
+      return response_model unless should_retry
+
+      # Calculate delay before next retry (in seconds)
+      delay_seconds = calculate_retry_delay(attempt_index, retry_config)
+
+      # Log retry attempt
+      LoggerService.log(
+        LogLevelEnum::ERROR,
+        "ATTEMPTING_RETRY_FOR_FAILED_NETWORK_CALL",
+        {
+          endPoint: endpoint,
+          err: last_error_message,
+          delay: delay_seconds,
+          attempt: attempt_index + 1,
+          maxRetries: retry_config[:max_retries]
+        }.merge(extra_data), false
+      )
+
+      # Store last error on request for diagnostics
+      request_model.set_last_error(last_error_message)
+
+      sleep(delay_seconds)
+    end
+
+    # All attempts exhausted
+    total_attempts = retry_config[:max_retries]
+    final_error_message = last_error_message || 'Unknown error'
+
+    # Log failure after max retries (skip for debugger events)
+    unless endpoint.include?(EventEnum::DEBUGGER_EVENT)
+      LoggerService.log(
+        LogLevelEnum::ERROR,
+        "NETWORK_CALL_FAILURE_AFTER_MAX_RETRIES",
+        {
+          extraData: endpoint,
+          attempts: total_attempts,
+          err: final_error_message
+        }.merge(extra_data), 
+        false
+      )
+    end
+
+    if last_response_model
+      last_response_model.set_total_attempts(total_attempts)
+      last_response_model.set_error(final_error_message)
+      last_response_model
+    else
+      response_model = ResponseModel.new
+      response_model.set_error(final_error_message)
+      response_model.set_total_attempts(total_attempts)
+      response_model
+    end
+  end
+
+  # Performs a single HTTP attempt (GET/POST) and returns:
+  # [ResponseModel, should_retry (Boolean), last_error_message (String or nil)]
+  def perform_single_attempt(uri, request_model, request_type, attempt, retry_config, prev_error_message = nil)
+    begin
+      # Low-level HTTP call
+      response = if request_type == :get_request
+                   perform_get_request(uri, request_model)
+                 else
+                   perform_post_request(uri, request_model)
+                 end
+
+      response_model = build_response_model(response)
+
+      # Success (2xx)
+      if response.is_a?(Net::HTTPSuccess)
+        # On retries, echo back last error and attempts (for diagnostics)
+        if attempt.positive?
+          response_model.set_total_attempts(attempt)
+          response_model.set_error(request_model.get_last_error)
+        end
+        return [response_model, false, nil]
+      end
+
+      # Client error 400 → do not retry
+      if response.code.to_i == 400
+        error_message = "#{response.body}, Status Code: #{response.code.to_i}"
+        response_model.set_error(error_message)
+        response_model.set_total_attempts(attempt)
+        return [response_model, false, error_message]
+      end
+
+      # Non-2xx/400 status → decide if we should retry based on status code
+      should_retry = should_retry(response, attempt, retry_config)
+      error_message = "#{response.body}, Status Code: #{response.code.to_i}"
+      response_model.set_error(error_message)
+      response_model.set_total_attempts(attempt)
+      [response_model, should_retry, error_message]
+    rescue StandardError => e
+      # Network / timeout / other exceptions
+      error_message = get_formatted_error_message(e)
+      response_model = ResponseModel.new
+      response_model.set_error(error_message)
+      response_model.set_total_attempts(attempt)
+
+      should_retry = should_retry_on_error(e, attempt, retry_config)
+      [response_model, should_retry, error_message]
+    end
+  end
+
+  def perform_get_request(uri, request_model)
+    request = Net::HTTP::Get.new(uri)
+    request_model.get_headers.each { |k, v| request[k] = v }
+
+    Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https', open_timeout: Constants::REQUEST_TIMEOUT, read_timeout: Constants::REQUEST_TIMEOUT) do |http|
+      http.request(request)
+    end
+  end
+
+  def perform_post_request(uri, request_model)
+    headers = request_model.get_headers
+    body = JSON.dump(request_model.get_body)
+
+    request = Net::HTTP::Post.new(uri, headers)
+    request.body = body
+
+    Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https', open_timeout: Constants::REQUEST_TIMEOUT, read_timeout: Constants::REQUEST_TIMEOUT) do |http|
+      http.request(request)
+    end
+  end
+
+  def build_response_model(response)
+    response_model = ResponseModel.new
+    response_model.set_status_code(response.code.to_i)
+
+    if response.is_a?(Net::HTTPSuccess) && !response.body.strip.empty?
+      content_type = response['Content-Type']&.downcase
+      if content_type&.include?('application/json')
+        begin
+          parsed_data = JSON.parse(response.body)
+          response_model.set_data(parsed_data)
+        rescue JSON::ParserError => e
+          response_model.set_error("Invalid JSON response: #{e.message}")
+        end
+      else
+        response_model.set_data(response.body)
+      end
+    end
+
+    response_model
+  end
+
+  def should_retry(response, attempt, retry_config)
+    # Retry on server errors (5xx) or network timeouts
+    status_code = response.code.to_i
+    status_code < 200 || status_code > 300
+  end
+
+  def should_retry_on_error(error, attempt, retry_config)
+    return false if attempt >= retry_config[:max_retries]
+
+    # Retry on network errors, timeouts, and connection errors
+    # Check for specific error types that indicate transient network issues
+    retryable = error.is_a?(Net::OpenTimeout) ||
+                error.is_a?(Net::ReadTimeout) ||
+                error.is_a?(Errno::ECONNREFUSED) ||
+                error.is_a?(Errno::ETIMEDOUT) ||
+                error.is_a?(Errno::EHOSTUNREACH) ||
+                error.is_a?(Errno::ENETUNREACH) ||
+                error.is_a?(Errno::ECONNRESET) ||
+                error.is_a?(Errno::EPIPE) ||
+                error.is_a?(SocketError) ||
+                (error.respond_to?(:message) && error.message && 
+                 (error.message.downcase.include?('timeout') || 
+                  error.message.downcase.include?('connection') ||
+                  error.message.downcase.include?('connection refused') ||
+                  error.message.downcase.include?('getaddrinfo') ||
+                  error.message.downcase.include?('connection reset') ||
+                  error.message.downcase.include?('broken pipe')))
+
+    retryable
+  end
+
+  def calculate_retry_delay(attempt, retry_config)
+    retry_config[:initial_delay] * (retry_config[:backoff_multiplier] ** attempt)
+  end
+
+  
+end

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

@@ -0,0 +1,37 @@
+# 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/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/wingify/packages/network_layer/manager/network_manager.rb

@@ -0,0 +1,145 @@
+# 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 '../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'
+require_relative '../../../enums/api_enum'
+require_relative '../../../utils/data_type_util'
+
+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
+    @retry_config = nil
+  end
+
+  def self.instance(options = {})
+    @instance ||= new(options)
+  end
+
+  def attach_client(client = nil, retry_config = nil)
+    # Only set retry configuration if it's not already initialized or if a new config is provided
+    if !@retry_config || retry_config
+      # Define default retry configuration
+      default_retry_config = Constants::DEFAULT_RETRY_CONFIG.dup
+
+      # Merge provided retry_config with defaults, giving priority to provided values
+      merged_config = default_retry_config.merge(retry_config || {})
+
+      # Validate the merged configuration
+      @retry_config = validate_retry_config(merged_config)
+    end
+  end
+
+  def get_retry_config
+    @retry_config ? @retry_config.dup : nil
+  end
+
+  def validate_retry_config(retry_config)
+    validated_config = retry_config.dup
+    is_invalid_config = false
+
+    # Validate should_retry: should be a boolean value
+    if !DataTypeUtil.is_boolean(validated_config[:should_retry])
+      validated_config[:should_retry] = Constants::DEFAULT_RETRY_CONFIG[:should_retry]
+      is_invalid_config = true
+    end
+
+    # Validate max_retries: should be a non-negative integer and should not be less than 1
+    if !DataTypeUtil.is_number(validated_config[:max_retries]) ||
+       !validated_config[:max_retries].is_a?(Integer) ||
+       validated_config[:max_retries] < 1
+      validated_config[:max_retries] = Constants::DEFAULT_RETRY_CONFIG[:max_retries]
+      is_invalid_config = true
+    end
+
+    # Validate initial_delay: should be a non-negative integer and should not be less than 1
+    if !DataTypeUtil.is_number(validated_config[:initial_delay]) ||
+       !validated_config[:initial_delay].is_a?(Integer) ||
+       validated_config[:initial_delay] < 1
+      validated_config[:initial_delay] = Constants::DEFAULT_RETRY_CONFIG[:initial_delay]
+      is_invalid_config = true
+    end
+
+    # Validate backoff_multiplier: should be a non-negative integer and should not be less than 2
+    if !DataTypeUtil.is_number(validated_config[:backoff_multiplier]) ||
+       !validated_config[:backoff_multiplier].is_a?(Integer) ||
+       validated_config[:backoff_multiplier] < 2
+      validated_config[:backoff_multiplier] = Constants::DEFAULT_RETRY_CONFIG[:backoff_multiplier]
+      is_invalid_config = true
+    end
+
+    if is_invalid_config
+      LoggerService.log(LogLevelEnum::ERROR, "INVALID_RETRY_CONFIG", {
+        retryConfig: validated_config.to_json,
+        an: ApiEnum::INIT
+      })
+    end
+
+    is_invalid_config ? Constants::DEFAULT_RETRY_CONFIG.dup : validated_config
+  end
+
+  def get_client
+    @client
+  end
+
+  def set_config(config)
+    @config = config
+  end
+
+  def get_config
+    @config
+  end
+
+  def create_request(request)
+    network_request = RequestHandler.new.create_request(request, @config)
+    # Set retry config from network manager if not already set in request
+    if @retry_config && (!network_request.get_retry_config || network_request.get_retry_config.nil?)
+      network_request.set_retry_config(@retry_config.dup)
+    end
+    network_request
+  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
+      return ResponseModel.new.set_error(e.message)
+    end
+  end
+  
+
+  def post(request)
+    begin
+      network_options = create_request(request)
+      raise 'No URL found' if network_options.get_url.nil?
+  
+      response = @client.post(network_options) # Return the response
+      response
+    rescue => e
+      return ResponseModel.new.set_error(e.message) # Return error response
+    end
+  end
+end