wingify-fme-ruby-sdk 1.50.0

data/lib/wingify/services/settings_service.rb

@@ -0,0 +1,178 @@
+# 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 '../packages/network_layer/manager/network_manager'
+require_relative '../packages/network_layer/models/request_model'
+require_relative '../packages/network_layer/models/response_model'
+require_relative '../constants/constants'
+require_relative '../utils/network_util'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../models/schemas/settings_schema_validation'
+require_relative '../enums/api_enum'
+require_relative '../utils/debugger_service_util'
+require_relative '../utils/brand_context'
+require_relative '../utils/brand_util'
+
+class SettingsService
+  attr_accessor :sdk_key, :account_id, :expiry, :network_timeout, :hostname, :events_hostname, :sdk_name, :port, :protocol, :is_gateway_service_provided, :is_settings_valid, :settings_fetch_time, :proxy_url, :is_proxy_url_provided, :collection_prefix
+
+  class << self
+    attr_accessor :instance
+
+    def get_instance
+      @instance ||= SettingsService.new
+    end
+
+    def normalize_settings(settings)
+      normalized_settings = settings.dup
+      normalized_settings['features'] = [] if normalized_settings['features'].is_a?(Hash) && normalized_settings['features'].empty?
+      normalized_settings['campaigns'] = [] if normalized_settings['campaigns'].is_a?(Hash) && normalized_settings['campaigns'].empty?
+      normalized_settings
+    end
+  end
+
+  def initialize(options)
+    @sdk_key = options[:sdk_key]
+    @account_id = options[:account_id]
+    @expiry = options.dig(:settings, :expiry) || Constants::SETTINGS_EXPIRY
+    @network_timeout = options.dig(:settings, :timeout) || Constants::SETTINGS_TIMEOUT
+    @is_settings_valid = false
+
+    if options[:gateway_service] && options[:gateway_service][:url]
+      parsed_url = URI.parse(options[:gateway_service][:url].start_with?(Constants::HTTP_PROTOCOL) || options[:gateway_service][:url].start_with?(Constants::HTTPS_PROTOCOL) ? options[:gateway_service][:url] : "#{Constants::HTTPS_PROTOCOL}#{options[:gateway_service][:url]}")
+      @hostname = parsed_url.hostname
+      @events_hostname = parsed_url.hostname
+      @sdk_name = BrandUtil.get_sdk_name(BrandContext.is_via_vwo?)
+      @protocol = parsed_url.scheme
+      @port = parsed_url.port || options.dig(:gateway_service, :port)
+      @is_gateway_service_provided = true
+      if options[:proxy_url] && !options[:proxy_url].nil? && !options[:proxy_url].empty?
+        LoggerService.log(LogLevelEnum::INFO, "PROXY_AND_GATEWAY_SERVICE_PROVIDED")
+      end
+    elsif options[:proxy_url] && !options[:proxy_url].nil? && !options[:proxy_url].empty?
+      parsed_url = URI.parse(options[:proxy_url])
+      @hostname = parsed_url.hostname
+      @events_hostname = parsed_url.hostname
+      @sdk_name = BrandUtil.get_sdk_name(BrandContext.is_via_vwo?)
+      @protocol = parsed_url.scheme
+      @port = parsed_url.port
+      @is_proxy_url_provided = true
+    else
+      is_via_vwo = BrandContext.is_via_vwo?
+      @hostname = BrandUtil.get_settings_hostname(is_via_vwo)
+      @events_hostname = BrandUtil.get_events_hostname(is_via_vwo)
+      @sdk_name = BrandUtil.get_sdk_name(is_via_vwo)
+      @protocol = Constants::HTTPS_PROTOCOL
+    end
+
+    LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", { service: 'Settings Manager' })
+    SettingsService.instance = self
+  end
+
+  def get_updated_endpoint_with_collection_prefix(endpoint, is_gateway_provided = false)
+    if is_gateway_provided
+      return endpoint
+    end
+
+    if @collection_prefix && !@collection_prefix.empty?
+      return "/#{@collection_prefix}#{endpoint}"
+    end
+    return endpoint
+  end
+
+  # Fetch settings and cache them in storage.
+  # @return [SettingsModel] The fetched settings
+  def fetch_settings_and_cache_in_storage
+    begin
+      response = fetch_settings
+      response
+    rescue => e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_FETCHING_SETTINGS", { err: e.message, an: ApiEnum::INIT}, false)
+      {}
+    end
+  end
+
+  # Fetch settings from the server.
+  # @param is_via_webhook [Boolean] Whether to fetch settings via webhook
+  # @return [SettingsModel] The fetched settings
+  def fetch_settings(is_via_webhook = false)
+    if @sdk_key.nil? || @account_id.nil?
+      LoggerService.log(LogLevelEnum::ERROR, "INVALID_SDK_KEY_OR_ACCOUNT_ID", { an: ApiEnum::INIT})
+    end
+
+    network_instance = NetworkManager.instance
+    options = NetworkUtil.get_settings_path(@sdk_key, @account_id)
+
+    options['api-version'] = Constants::API_VERSION
+    options[:source] = 'prod'
+    options[:sn] = @sdk_name
+    options[:sv] = Constants::SDK_VERSION
+
+    # When using gateway service, always fetch from SETTINGS_ENDPOINT since the gateway maintains the latest settings
+    if @is_gateway_service_provided
+      path = Constants::SETTINGS_ENDPOINT
+    else
+      path = is_via_webhook ? Constants::WEBHOOK_SETTINGS_ENDPOINT : Constants::SETTINGS_ENDPOINT
+    end
+
+    request = RequestModel.new(@hostname, "GET", path, options, nil, nil, @protocol, @port)
+    request.set_timeout(@network_timeout)
+
+    # store the current time in milliseconds
+    settings_fetch_start_time = (Time.now.to_f * 1000).to_i
+
+    begin
+      response = network_instance.get(request)
+      # calculate the time taken to fetch the settings
+      settings_fetch_end_time = (Time.now.to_f * 1000).to_i
+      time_taken = settings_fetch_end_time - settings_fetch_start_time
+      @settings_fetch_time = time_taken.to_s
+
+      if response.get_total_attempts > 0
+        api_enum = is_via_webhook ? ApiEnum::UPDATE_SETTINGS : ApiEnum::INIT
+        debug_event_props = NetworkUtil.create_network_and_retry_debug_event(response, nil, api_enum, path)
+        # send debug event
+        DebuggerServiceUtil.send_debugger_event(debug_event_props)
+      end
+      settings = response.get_data
+      if settings.nil? || settings.empty?
+        settings = {}
+      end
+      # Deep duplicate the settings to avoid modifying the original object
+      normalized_settings = SettingsService.normalize_settings(settings)
+      @collection_prefix = normalized_settings['collectionPrefix'] if normalized_settings['collectionPrefix'] && !normalized_settings['collectionPrefix'].empty?
+      normalized_settings
+    rescue => e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_FETCHING_SETTINGS", { err: e.message, an: ApiEnum::INIT})
+      {}
+    end
+  end
+
+  # Get settings (either from storage or by forcing fetch).
+  # @return [SettingsModel] The fetched settings
+  def get_settings
+    settings = fetch_settings_and_cache_in_storage
+    is_valid = SettingsSchema.new.is_settings_valid(settings)
+    if is_valid
+      @is_settings_valid = true
+      LoggerService.log(LogLevelEnum::INFO, "SETTINGS_FETCH_SUCCESS")
+      settings
+    else
+      LoggerService.log(LogLevelEnum::ERROR, "INVALID_SETTINGS_SCHEMA", { accountId: @account_id, sdkKey: @sdk_key, settings: settings, an: ApiEnum::INIT}, false)
+      {}
+    end
+  end
+end

data/lib/wingify/services/storage_service.rb

@@ -0,0 +1,66 @@
+# 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 '../enums/storage_enum'
+require_relative '../models/user/context_model'
+require_relative '../packages/storage/storage'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../utils/data_type_util'
+require_relative '../enums/api_enum'
+
+class StorageService
+  attr_accessor :storage_data
+
+  def initialize
+    @storage_data = {}
+  end
+
+  # Retrieves data from storage based on the feature key and user ID.
+  # @param feature_key [String] The key to identify the feature data.
+  # @param context [ContextModel] The user context containing an ID.
+  # @return [Hash] The data retrieved or a storage status enum.
+  def get_data_from_storage(feature_key, context)
+    storage_instance = Storage.instance.get_connector
+
+    # Check if the storage instance is available
+    return StorageEnum::STORAGE_UNDEFINED if DataTypeUtil.is_null(storage_instance) || DataTypeUtil.is_undefined(storage_instance)
+
+    begin
+      data = storage_instance.get(feature_key, context.get_id)
+      return data.nil? ? StorageEnum::NO_DATA_FOUND : data
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_READING_DATA_FROM_STORAGE", { err: e.message, an: ApiEnum::GET_FLAG, sId: context.get_session_id, uuid: context.get_uuid})
+      return StorageEnum::NO_DATA_FOUND
+    end
+  end
+
+  # Stores data in the storage.
+  # @param data [Hash] The data to be stored.
+  # @return [Boolean] True if data is successfully stored, otherwise false.
+  def set_data_in_storage(data, context)
+    storage_instance = Storage.instance.get_connector
+
+    # Check if the storage instance is available
+    return false if storage_instance.nil?
+
+    begin
+      storage_instance.set(data)
+      return true
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_STORING_DATA_IN_STORAGE", { err: e.message, an: ApiEnum::GET_FLAG, sId: context.get_session_id, uuid: context.get_uuid})
+      return false
+    end
+  end
+end

data/lib/wingify/utils/batch_event_dispatcher_util.rb

@@ -0,0 +1,178 @@
+# 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 'set'
+require_relative './network_util'
+require_relative '../enums/http_method_enum'
+require_relative '../enums/url_enum'
+require_relative '../enums/log_level_enum'
+require_relative '../enums/event_enum'
+require_relative '../services/logger_service'
+require_relative '../packages/network_layer/manager/network_manager'
+require_relative '../packages/network_layer/models/request_model'
+require_relative '../packages/network_layer/models/response_model'
+require_relative '../utils/function_util'
+
+class BatchEventDispatcherUtil
+
+  class << self
+
+    # Dispatches a batch of events to the VWO server
+    # @param properties [Hash] The event properties to send
+    # @param callback [Proc] Optional callback function to execute after the request (defaults to empty proc)
+    # @param query_params [Hash] Query parameters to include in the request
+    def dispatch(properties, callback = -> {}, query_params)
+      # Send the prepared payload via POST API request
+      send_batch_post_api_request(query_params, properties, callback)
+    end
+
+    # Sends a POST API request with given properties and payload
+    def send_batch_post_api_request(properties, payload, callback)
+      network_instance = NetworkManager.instance
+      headers = {}
+      headers['Authorization'] = "#{SettingsService.instance.sdk_key}"
+
+      request = RequestModel.new(
+        SettingsService.instance.events_hostname,
+        HttpMethodEnum::POST,
+        SettingsService.instance.get_updated_endpoint_with_collection_prefix(UrlEnum::BATCH_EVENTS, SettingsService.instance.is_gateway_service_provided),
+        properties,
+        payload,
+        headers,
+        SettingsService.instance.protocol,
+        SettingsService.instance.port
+      )
+      
+      event_counts = extract_event_counts(payload)
+      extra_data = "#{Constants::BATCH_EVENTS} having"
+      if event_counts[:variation_shown_count] > 0
+        extra_data += "getFlag events: #{event_counts[:variation_shown_count]}, "
+      end
+      if event_counts[:custom_event_count] > 0
+        extra_data += "conversion events: #{event_counts[:custom_event_count]}, "
+      end
+      if event_counts[:set_attribute_count] > 0
+        extra_data += "setAttribute events: #{event_counts[:set_attribute_count]}, "
+      end
+
+      begin
+        response = network_instance.post(request)
+        # Only send debug event if response is valid and has retry attempts
+        if response.is_a?(ResponseModel) && response.get_total_attempts && response.get_total_attempts > 0
+          debug_event_props = NetworkUtil.create_network_and_retry_debug_event(response, nil, Constants::BATCH_EVENTS, extra_data)
+          # send debug event
+          DebuggerServiceUtil.send_debugger_event(debug_event_props) if debug_event_props
+        end
+        handle_batch_response(UrlEnum::BATCH_EVENTS, payload, properties, response, response.get_data, callback)
+      rescue StandardError => err
+        # TODO: remove this log after testing
+        LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
+              method: extra_data,
+              err: get_formatted_error_message(err)
+          })
+      end
+    end
+
+    # Handles the response from a batch event API call
+    # @param end_point [String] The API endpoint that was called
+    # @param payload [Hash] The payload that was sent in the request
+    # @param query_params [Hash] The query parameters used in the request
+    # @param res [ResponseModel] The response object from the API call
+    # @param raw_data [String] The raw response data from the API
+    # @param callback [Proc] Optional callback to be executed after handling the response
+    def handle_batch_response(end_point, payload, query_params, res, raw_data, callback)
+      # TODO: update this method with debug event logs
+      events_per_request = payload[:ev].length
+      account_id = query_params[:a]
+
+      error = res.get_error
+      if error
+        LoggerService.log(LogLevelEnum::INFO, "IMPRESSION_BATCH_FAILED")
+        LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
+          method: "#{HttpMethodEnum::POST} #{UrlEnum::BATCH_EVENTS}",
+          err: error
+        }, false)
+        callback.call(error, payload.to_json) if callback.respond_to?(:call)
+        return {status: "error", events: payload}
+      else
+        case res.get_status_code
+        when 200
+          LoggerService.log(LogLevelEnum::INFO, "IMPRESSION_BATCH_SUCCESS", {
+            accountId: account_id,
+            endPoint: end_point,
+          })
+          callback.call(nil, payload.to_json) if callback.respond_to?(:call)
+          return {status: "success", events: payload}
+        when 413
+          LoggerService.log(LogLevelEnum::DEBUG, "CONFIG_BATCH_EVENT_LIMIT_EXCEEDED", {
+              accountId: account_id,
+              endPoint: end_point,
+              eventsPerRequest: events_per_request
+          })
+          LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
+              method: "#{HttpMethodEnum::POST} #{UrlEnum::BATCH_EVENTS}",
+              err: error
+          }, false)
+          callback.call(error, payload.to_json) if callback.respond_to?(:call)
+          return {status: "error", events: payload}
+        else
+          LoggerService.log(LogLevelEnum::INFO, "IMPRESSION_BATCH_FAILED")
+          LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
+              method: "#{HttpMethodEnum::POST} #{UrlEnum::BATCH_EVENTS}",
+              err: error
+          }, false)
+          callback.call(error, payload.to_json) if callback.respond_to?(:call)
+          return {status: "error", events: payload}
+        end
+      end
+    end
+
+    # Extracts event counts from a batch payload
+    # @param payload [Hash] The payload containing events
+    # @return [Hash] Hash with variationShownCount, setAttributeCount, and customEventCount
+    def extract_event_counts(payload)
+      counts = {
+        variation_shown_count: 0,
+        set_attribute_count: 0,
+        custom_event_count: 0
+      }
+
+      # Get all standard event names from EventEnum
+      standard_event_names = EventEnum.constants.map { |const| EventEnum.const_get(const) }.to_set
+      events = payload&.dig(:ev) || []
+
+      events.each do |entry|
+        name = entry&.dig(:d, :event, :name)
+
+        next unless name
+
+        if name == EventEnum::VARIATION_SHOWN
+          counts[:variation_shown_count] += 1
+          next
+        end
+
+        if name == EventEnum::SYNC_VISITOR_PROP
+          counts[:set_attribute_count] += 1
+          next
+        end
+
+        unless standard_event_names.include?(name)
+          counts[:custom_event_count] += 1
+        end
+      end
+
+      counts
+    end
+  end
+end

data/lib/wingify/utils/brand_context.rb

@@ -0,0 +1,33 @@
+# 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.
+
+# BrandContext holds a single runtime flag that is set ONCE at init() time,
+# before any service (Logger, SettingsService, etc.) is initialized.
+# All brand-specific decisions (hostnames, SDK name, log prefix) read this flag.
+module BrandContext
+  @is_via_vwo = false
+
+  class << self
+    # Set the brand flag. Must be called as the very first step inside init().
+    # @param val [Boolean] true = VWO brand, false = Wingify brand
+    def set_is_via_vwo(val)
+      @is_via_vwo = val == true
+    end
+
+    # @return [Boolean] true if the active brand is VWO
+    def is_via_vwo?
+      @is_via_vwo
+    end
+  end
+end

data/lib/wingify/utils/brand_util.rb

@@ -0,0 +1,53 @@
+# 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'
+
+# BrandUtil provides pure, side-effect-free selectors for brand-specific constants.
+# Every method takes an explicit is_via_vwo boolean so it can be used
+# both at init time (reading BrandContext) and in tests (passed directly).
+module BrandUtil
+  # Returns the gem/SDK name sent in network requests.
+  # Values: 'vwo-fme-ruby-sdk' or 'wingify-fme-ruby-sdk'
+  def self.get_sdk_name(is_via_vwo)
+    is_via_vwo ? Constants::VWO_SDK_NAME : Constants::WINGIFY_SDK_NAME
+  end
+
+  # Returns the hostname used to FETCH SETTINGS.
+  # VWO:     dev.visualwebsiteoptimizer.com
+  # Wingify: edge.wingify.net
+  def self.get_settings_hostname(is_via_vwo)
+    is_via_vwo ? Constants::VWO_HOST_NAME : Constants::WINGIFY_SETTINGS_HOST_NAME
+  end
+
+  # Returns the hostname used for ALL COLLECT / EVENT calls
+  # (track user, track goal, set attribute, batch events, usage stats, debugger events, SDK init event).
+  # VWO:     dev.visualwebsiteoptimizer.com
+  # Wingify: collect.wingify.net
+  def self.get_events_hostname(is_via_vwo)
+    is_via_vwo ? Constants::VWO_HOST_NAME : Constants::WINGIFY_COLLECTION_HOST_NAME
+  end
+
+  # Returns the log prefix shown in every log line.
+  # Values: 'VWO-SDK' or 'Wingify-SDK'
+  def self.get_log_prefix(is_via_vwo)
+    is_via_vwo ? Constants::VWO_LOG_PREFIX : Constants::WINGIFY_LOG_PREFIX
+  end
+
+  # Returns the human-readable brand display name used in messages.
+  # Values: 'VWO' or 'Wingify'
+  def self.get_brand_name(is_via_vwo)
+    is_via_vwo ? Constants::VWO_BRAND_DISPLAY_NAME : Constants::WINGIFY_BRAND_DISPLAY_NAME
+  end
+end