vwo-fme-ruby-sdk 1.6.1 → 1.8.0

data/lib/vwo/utils/network_util.rb

@@ -21,10 +21,12 @@ require_relative '../constants/constants'
 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/url_util'
 require_relative '../utils/uuid_util'
 require_relative '../utils/usage_stats_util'
 require_relative '../models/user/context_model'
+require_relative '../utils/log_message_util'
+require_relative '../utils/function_util'
+require_relative '../enums/api_enum'
 
 class NetworkUtil
   class << self
@@ -89,8 +91,7 @@ class NetworkUtil
             random: get_random_number,
             p: 'FS',
             visitor_ua: visitor_user_agent || '',
-            visitor_ip: ip_address || '',
-            url: "#{UrlUtil.get_base_url}#{UrlEnum::EVENTS}"
+            visitor_ip: ip_address || ''
         }
 
         if !is_usage_stats_event
@@ -260,37 +261,76 @@ class NetworkUtil
     end
 
     # Sends a POST API request with given properties and payload
-    def send_post_api_request(properties, payload)
+    def send_post_api_request(properties, payload, campaign_info = {})
         network_instance = NetworkManager.instance
         headers = {}
         headers[HeadersEnum::USER_AGENT] = payload[:d][:visitor_ua] if payload[:d][:visitor_ua]
         headers[HeadersEnum::IP] = payload[:d][:visitor_ip] if payload[:d][:visitor_ip]
 
         request = RequestModel.new(
-        UrlUtil.get_base_url,
+        SettingsService.instance.hostname,
         HttpMethodEnum::POST,
-        UrlEnum::EVENTS,
+        SettingsService.instance.get_updated_endpoint_with_collection_prefix(UrlEnum::EVENTS),
         properties,
         payload,
         headers,
         SettingsService.instance.protocol,
         SettingsService.instance.port
         )
-
+        
+        api_name = nil
+        extra_data_for_message = nil
+        if properties.key?(:en) && properties[:en] == EventEnum::VWO_VARIATION_SHOWN
+          api_name = ApiEnum::GET_FLAG
+          if campaign_info && campaign_info.key?(:campaign_type) && (campaign_info[:campaign_type] == CampaignTypeEnum::ROLLOUT || campaign_info[:campaign_type] == CampaignTypeEnum::PERSONALIZE)
+            extra_data_for_message = "feature: #{campaign_info[:feature_key]}, rule: #{campaign_info[:variation_name]}"
+          elsif campaign_info
+            extra_data_for_message = "feature: #{campaign_info[:feature_key]}, rule: #{campaign_info[:campaign_key]} and variation: #{campaign_info[:variation_name]}"
+          end
+        elsif properties.key?(:en) && properties[:en] != EventEnum::VWO_VARIATION_SHOWN
+          if properties.key?(:en) && properties[:en] == EventEnum::VWO_SYNC_VISITOR_PROP
+            api_name = ApiEnum::SET_ATTRIBUTE
+            extra_data_for_message = api_name
+          elsif properties.key?(:en) && properties[:en] != EventEnum::VWO_VARIATION_SHOWN && properties[:en] != EventEnum::VWO_DEBUGGER_EVENT && properties[:en] != EventEnum::VWO_INIT_CALLED
+            api_name = ApiEnum::TRACK_EVENT
+            extra_data_for_message = "event: #{properties[:en]}"
+          end
+        end
         begin
             if network_instance.get_client.get_should_use_threading
                 network_instance.get_client.get_thread_pool.post {
                     response = network_instance.post(request)
+                    if response.get_total_attempts > 0
+                      debug_event_props = create_network_and_retry_debug_event(response, request.get_body, api_name, extra_data_for_message)
+                      debug_event_props[:uuid] = request.get_body[:d][:visId]
+                      DebuggerServiceUtil.send_debugger_event(debug_event_props)
+                    end
+                    if response.get_status_code == 200
+                      LoggerService.log(LogLevelEnum::INFO, "NETWORK_CALL_SUCCESS", {
+                        event: properties[:en],
+                        endPoint: UrlEnum::EVENTS,
+                        accountId: SettingsService.instance.account_id,
+                        uuid: request.get_body[:d][:visId]
+                      })
+                    end
                     response
                 }
             else
                 response = network_instance.post(request)
+                if response.get_status_code == 200
+                    LoggerService.log(LogLevelEnum::INFO, "NETWORK_CALL_SUCCESS", {
+                        event: properties[:en],
+                        endPoint: UrlEnum::EVENTS,
+                        accountId: SettingsService.instance.account_id,
+                        uuid: request.get_body[:d][:visId]
+                    })
+                end
                 response
             end
         rescue ResponseModel => err
             LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
-                method: HttpMethodEnum::POST,
-                err: err.is_a?(Hash) ? err.to_json : err
+                method: extra_data_for_message,
+                err: get_formatted_error_message(err.get_error)
             })
         end
     end
@@ -305,59 +345,126 @@ class NetworkUtil
         headers[HeadersEnum::USER_AGENT] = payload[:d][:visitor_ua] if payload[:d][:visitor_ua]
         headers[HeadersEnum::IP] = payload[:d][:visitor_ip] if payload[:d][:visitor_ip]
 
-        url = Constants::HOST_NAME
-        if UrlUtil.get_collection_prefix && !UrlUtil.get_collection_prefix.empty?
-            url = "#{url}/#{UrlUtil.get_collection_prefix}"
-        end
-
         request = RequestModel.new(
-            url,
+            SettingsService.instance.hostname,
             HttpMethodEnum::POST,
-            UrlEnum::EVENTS,
+            SettingsService.instance.get_updated_endpoint_with_collection_prefix(UrlEnum::EVENTS),
             properties,
             payload,
             headers,
-            Constants::HTTPS_PROTOCOL,
-            nil
+            SettingsService.instance.protocol,
+            SettingsService.instance.port,
         )
 
         begin
             if network_instance.get_client.get_should_use_threading
                 network_instance.get_client.get_thread_pool.post {
                     response = network_instance.post(request)
+                    if response.get_status_code == 200
+                        LoggerService.log(LogLevelEnum::INFO, "NETWORK_CALL_SUCCESS", {
+                            event: properties[:en],
+                            endPoint: UrlEnum::EVENTS,
+                            accountId: SettingsService.instance.account_id,
+                            uuid: request.get_body[:d][:visId]
+                        })
+                    end
                     response
                 }
             else
                 response = network_instance.post(request)
+                if response.get_status_code == 200
+                    LoggerService.log(LogLevelEnum::INFO, "NETWORK_CALL_SUCCESS", {
+                        event: properties[:en],
+                        endPoint: UrlEnum::EVENTS,
+                        accountId: SettingsService.instance.account_id,
+                        uuid: request.get_body[:d][:visId]
+                    })
+                end
                 response
             end
         rescue ResponseModel => err
+            if properties.key?(:en) && properties[:en] != EventEnum::VWO_DEBUGGER_EVENT
+              LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
+                method: "event: #{properties[:en]}",
+                err: get_formatted_error_message(err.get_error)
+              })
+            end
         end
     end
 
-    # Sends a GET API request to the specified endpoint with given properties
-    def send_get_api_request(properties, endpoint)
-        network_instance = NetworkManager.instance
+    # get debugger event payload
+    def get_debugger_event_payload(event_props)
+        user_id = SettingsService.instance.account_id.to_s + "_" + SettingsService.instance.sdk_key
+        properties = _get_event_base_payload(user_id, EventEnum::VWO_DEBUGGER_EVENT, nil, nil)
+        
+        # check if event_props contains uuid key and should be non null and non empty string
+        if event_props.key?(:uuid) && event_props[:uuid].is_a?(String) && !event_props[:uuid].empty?
+            properties[:d][:msgId] = "#{event_props[:uuid]}-#{get_current_unix_timestamp_in_millis}"
+            properties[:d][:visId] = event_props[:uuid]
+        else
+            event_props[:uuid] = properties[:d][:visId]
+        end
 
-        request = RequestModel.new(
-        UrlUtil.get_base_url,
-        HttpMethodEnum::GET,
-        endpoint,
-        properties,
-        nil,
-        nil,
-        SettingsService.Instance.protocol,
-        SettingsService.Instance.port
-        )
+        # check if event_props contains sessionId key 
+        if event_props.key?(:sId)
+            properties[:d][:sessionId] = event_props[:sId]
+        else
+            event_props[:sId] = properties[:d][:sessionId]
+        end
 
-        begin
-            network_instance.get(request)
-        rescue StandardError => err
-            LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
-                method: HttpMethodEnum::GET,
-                err: err.is_a?(Hash) ? err.to_json : err
-            })
+        event_props[:a] = SettingsService.instance.account_id.to_s
+        event_props[:product] = Constants::PRODUCT_NAME
+        event_props[:sn] = Constants::SDK_NAME
+        event_props[:sv] = Constants::SDK_VERSION
+        event_props[:eventId] = UUIDUtil.get_random_uuid(SettingsService.instance.sdk_key)
+
+        properties[:d][:event][:props] = {}
+        properties[:d][:event][:props][:vwoMeta] = event_props
+        properties
+    end
+
+    def create_network_and_retry_debug_event(response, payload, api_name, extra_data)
+      begin
+        category = DebugCategoryEnum::RETRY
+        msg_t = Constants::NETWORK_CALL_SUCCESS_WITH_RETRIES
+        msg = build_message(LoggerService.get_messages(LogLevelEnum::INFO)[msg_t], {
+          extraData: extra_data,
+          attempts: response.get_total_attempts,
+          err: get_formatted_error_message(response.get_error)
+        })
+        lt = LogLevelEnum::INFO.to_s
+        if response.get_status_code != 200
+          category = DebugCategoryEnum::NETWORK
+          msg_t = Constants::NETWORK_CALL_FAILURE_AFTER_MAX_RETRIES
+          msg = build_message(LoggerService.get_messages(LogLevelEnum::ERROR)[msg_t], {
+            extraData: extra_data,
+            attempts: response.get_total_attempts,
+            err: get_formatted_error_message(response.get_error)
+          })
+          lt = LogLevelEnum::ERROR.to_s
+        end
+        debug_event_props = {
+          cg: category,
+          msg_t: msg_t,
+          msg: msg,
+          lt: lt
+        }
+        if api_name
+          debug_event_props[:an] = api_name
         end
+
+        if payload && payload[:d] && payload[:d][:sessionId]
+          debug_event_props[:sId] = payload[:d][:sessionId]
+        else
+          debug_event_props[:sId] = get_current_unix_timestamp
+        end
+        debug_event_props
+      rescue StandardError => err
+        LoggerService.log(LogLevelEnum::ERROR, "NETWORK_CALL_FAILED", {
+          method: extra_data,
+          err: get_formatted_error_message(err)
+        })
+      end
     end
   end
 end

data/lib/vwo/utils/rule_evaluation_util.rb

@@ -49,7 +49,7 @@ def evaluate_rule(settings, feature, campaign, context, evaluated_feature_map, m
     )
 
     # Send an impression for the variation shown
-    create_and_send_impression_for_variation_shown(settings, campaign.get_id, whitelisted_object[:variation_id], context)
+    create_and_send_impression_for_variation_shown(settings, campaign.get_id, whitelisted_object[:variation_id], context, feature.get_key)
   end
 
   # Return the results of the evaluation

data/lib/vwo/vwo_builder.rb

@@ -23,9 +23,10 @@ require_relative './packages/segmentation_evaluator/core/segmentation_manager'
 require_relative './services/logger_service'
 require_relative './services/batch_event_queue'
 require_relative './utils/function_util'
-require_relative './utils/batch_event_dispatcher'
 require_relative './constants/constants'
 require_relative './utils/usage_stats_util'
+require_relative './enums/api_enum'
+require_relative './utils/batch_event_dispatcher_util'
 
 class VWOBuilder
   attr_reader :settings, :storage, :log_manager, :is_settings_fetch_in_progress, :vwo_instance, :is_valid_poll_interval_passed_from_init
@@ -61,7 +62,7 @@ class VWOBuilder
           
           if (!events_per_request.is_a?(Numeric) || events_per_request <= 0) &&
              (!request_time_interval.is_a?(Numeric) || request_time_interval <= 0)
-            LoggerService.log(LogLevelEnum::ERROR, "INVALID_BATCH_EVENTS_CONFIG")
+            LoggerService.log(LogLevelEnum::ERROR, "INVALID_BATCH_EVENTS_CONFIG", { an: ApiEnum::INIT})
           end
           
           BatchEventsQueue.configure(
@@ -74,11 +75,11 @@ class VWOBuilder
           )
           @batch_event_data = @options[:batch_event_data]
         else
-          LoggerService.log(LogLevelEnum::ERROR, "Invalid batch events config, should be a hash.", nil)
+          LoggerService.log(LogLevelEnum::ERROR, "INVALID_BATCH_EVENTS_CONFIG", { an: ApiEnum::INIT})
         end
       end
     rescue StandardError => e
-      LoggerService.log(LogLevelEnum::ERROR, "Failed to initialize batch event queue: #{e.message}", nil)
+      LoggerService.log(LogLevelEnum::ERROR, "FAILED_TO_INITIALIZE_SERVICE", { service: 'Batch Event Queue', err: e.message, an: ApiEnum::INIT})
     end
   end
 
@@ -87,12 +88,14 @@ class VWOBuilder
   def set_network_manager
     begin
       network_instance = NetworkManager.instance(@options[:threading] || {})
-      network_instance.attach_client(@options[:network][:client]) if @options[:network] && @options[:network][:client]
+      retry_config = @options[:retry_config]
+      client = (@options[:network] && @options[:network][:client]) ? @options[:network][:client] : nil
+      network_instance.attach_client(client, retry_config)
       LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", {service: "Network Layer"})
       network_instance.get_config.set_development_mode(@options[:is_development_mode]) if @options[:is_development_mode]
       self
     rescue StandardError => e
-      LoggerService.log(LogLevelEnum::ERROR, "Failed to initialize network manager: #{e.message}", nil)
+      LoggerService.log(LogLevelEnum::ERROR, "FAILED_TO_INITIALIZE_SERVICE", { service: 'Network Manager', err: e.message, an: ApiEnum::INIT})
       self
     end
   end
@@ -127,7 +130,7 @@ class VWOBuilder
     begin
       fetch_settings(force)
     rescue StandardError => e
-      LoggerService.log(LogLevelEnum::ERROR, "Failed to fetch settings: #{e.message}", nil)
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_FETCHING_SETTINGS", { err: e.message, an: ApiEnum::INIT})
       {}
     end
   end
@@ -175,9 +178,10 @@ class VWOBuilder
       check_and_poll
     elsif poll_interval
       # only log error if poll_interval is present in options
-      LoggerService.log(LogLevelEnum::ERROR, "INIT_OPTIONS_INVALID", {
+      LoggerService.log(LogLevelEnum::ERROR, "INVALID_POLLING_CONFIGURATION", {
         key: 'poll_interval',
-        correctType: 'number >= 1000'
+        correctType: 'number >= 1000',
+        an: ApiEnum::INIT
       })
     end
     self
@@ -227,14 +231,14 @@ class VWOBuilder
             LoggerService.log(LogLevelEnum::INFO, "POLLING_NO_CHANGE_IN_SETTINGS")
           end
         rescue StandardError => e
-          LoggerService.log(LogLevelEnum::ERROR, "POLLING_FETCH_SETTINGS_FAILED")
+          LoggerService.log(LogLevelEnum::ERROR, "ERROR_UPDATING_SETTINGS", { err: e.message, an: ApiEnum::INIT})
         end
       end
     end
   end
 
   def dispatcher(events, callback)
-    BatchEventDispatcher.dispatch(
+    BatchEventDispatcherUtil.dispatch(
       {
         ev: events
       },

data/lib/vwo/vwo_client.rb

@@ -17,13 +17,13 @@ require_relative 'models/user/context_model'
 require_relative 'api/get_flag'
 require_relative 'api/set_attribute'
 require_relative 'api/track_event'
-require_relative 'utils/url_util'
 require_relative 'utils/settings_util'
 require_relative 'services/logger_service'
 require_relative 'enums/log_level_enum'
 require_relative 'utils/network_util'
 require_relative 'models/schemas/settings_schema_validation'
 require_relative 'services/batch_event_queue'
+require_relative 'enums/api_enum'
 
 class VWOClient
   attr_accessor :settings, :original_settings
@@ -36,9 +36,8 @@ class VWOClient
     
     begin
       set_settings_and_add_campaigns_to_rules(settings, self)
-      UrlUtil.init(collection_prefix: @settings.get_collection_prefix)
     rescue StandardError => e
-      LoggerService.log(LogLevelEnum::ERROR, "Error setting and adding campaigns to rules message: #{e.message}", nil)
+      LoggerService.log(LogLevelEnum::ERROR, "ERROR_ADDING_CAMPAIGNS_TO_RULES", { err: e.message, an: ApiEnum::INIT})
     end
     LoggerService.log(LogLevelEnum::INFO, "CLIENT_INITIALIZED")
     self
@@ -57,26 +56,22 @@ class VWOClient
       LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
 
       unless feature_key.is_a?(String) && !feature_key.empty?
-        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'feature_key', type: feature_key.class.name , correctType: 'String'})
         raise TypeError, 'feature_key should be a non-empty string'
       end
       unless SettingsService.instance.is_settings_valid
-        LoggerService.log(LogLevelEnum::ERROR, "API_SETTING_INVALID")
         raise TypeError, 'Invalid Settings'
       end
       unless context.is_a?(Hash)
-        LoggerService.log(LogLevelEnum::ERROR, "API_CONTEXT_INVALID")
         raise TypeError, 'Invalid context'
       end
       unless context[:id].is_a?(String) && !context[:id].empty?
-        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'context.id', type: context[:id].class.name, correctType: 'String'})
         raise TypeError, 'Invalid context, id should be a non-empty string'
       end
       
       context_model = ContextModel.new.model_from_dictionary(context)
       FlagApi.new.get(feature_key, @settings, context_model, hooks_service)
     rescue StandardError => e
-      LoggerService.log(LogLevelEnum::ERROR, "API_THROW_ERROR", {apiName: api_name, err: e.message})
+      LoggerService.log(LogLevelEnum::ERROR, "EXECUTION_FAILED", {apiName: api_name, err: e.message, an: ApiEnum::GET_FLAG})
       error_response
     end
   end
@@ -94,26 +89,22 @@ class VWOClient
       LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
       
       unless event_name.is_a?(String) && !event_name.empty?
-        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'event_name', type: event_name.class.name, correctType: 'String'})
         raise TypeError, 'event_name should be a non-empty string'
       end
       unless event_properties.is_a?(Hash)
-        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'event_properties', type: event_properties.class.name, correctType: 'Hash'})
         raise TypeError, 'event_properties should be a hash'
       end
       unless SettingsService.instance.is_settings_valid
-        LoggerService.log(LogLevelEnum::ERROR, "API_SETTING_INVALID")
         raise TypeError, 'Invalid Settings'
       end
       unless context[:id].is_a?(String) && !context[:id].empty?
-        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'context.id', type: context[:id].class.name, correctType: 'String'})
         raise TypeError, 'Invalid context, id should be a non-empty string'
       end
       
       context_model = ContextModel.new.model_from_dictionary(context)
       TrackApi.new.track(@settings, event_name, context_model, event_properties, hooks_service)
     rescue StandardError => e
-      LoggerService.log(LogLevelEnum::ERROR, "API_THROW_ERROR", {apiName: api_name, err: e.message})
+      LoggerService.log(LogLevelEnum::ERROR, "EXECUTION_FAILED", {apiName: api_name, err: e.message, an: ApiEnum::TRACK_EVENT})
       { event_name: false }
     end
   end
@@ -129,26 +120,22 @@ class VWOClient
       LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
 
       unless attributes.is_a?(Hash) && !attributes.empty?
-        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'attributes', type: attributes.class.name, correctType: 'Hash'})
         raise TypeError, 'Attributes should be a hash with key-value pairs and non-empty'
       end
       unless context.is_a?(Hash)
-        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'context', type: context.class.name, correctType: 'Hash'})
         raise TypeError, 'Invalid context'
       end
       unless context[:id].is_a?(String) && !context[:id].empty?
-        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'context.id', type: context[:id].class.name, correctType: 'String'})
         raise TypeError, 'Invalid context, id should be a non-empty string'
       end
       unless SettingsService.instance.is_settings_valid
-        LoggerService.log(LogLevelEnum::ERROR, "API_SETTING_INVALID")
         raise TypeError, 'Invalid Settings'
       end
       
       context_model = ContextModel.new.model_from_dictionary(context)
       SetAttributeApi.new.set_attribute(attributes, context_model)
     rescue StandardError => e
-      LoggerService.log(LogLevelEnum::ERROR, "API_THROW_ERROR", {apiName: api_name, err: e.message})
+      LoggerService.log(LogLevelEnum::ERROR, "EXECUTION_FAILED", {apiName: api_name, err: e.message, an: ApiEnum::SET_ATTRIBUTE})
     end
   end
 
@@ -171,8 +158,7 @@ class VWOClient
 
       # Validate settings schema
       unless SettingsSchema.new.is_settings_valid(settings_to_update)
-        LoggerService.log(LogLevelEnum::ERROR, "API_SETTING_INVALID")
-        raise TypeError, 'Invalid Settings'
+        raise TypeError, "Got Invalid Settings, settings: #{settings_to_update}"
       end
 
       # Set the settings on the client instance
@@ -181,12 +167,13 @@ class VWOClient
     rescue StandardError => e
       LoggerService.log(
         LogLevelEnum::ERROR,
-        "SETTINGS_FETCH_FAILED",
+        "UPDATING_CLIENT_INSTANCE_FAILED_WHEN_WEBHOOK_TRIGGERED",
         {
           apiName: api_name,
           isViaWebhook: is_via_webhook,
-          err: e.message
-        }
+          err: e.message,
+          an: ApiEnum::UPDATE_SETTINGS
+        }, false
       )
     end
   end
@@ -198,14 +185,13 @@ class VWOClient
     begin
       LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
       if BatchEventsQueue.instance.nil?
-        LoggerService.log(LogLevelEnum::ERROR, "Batching is not enabled. Pass batch_event_data in the SDK configuration while invoking init API.", nil)
         raise StandardError, "Batch events queue is not initialized"
       end
       # flush the batch events queue
       @response = BatchEventsQueue.instance.flush(true)
       @response
     rescue StandardError => e
-      LoggerService.log(LogLevelEnum::ERROR, "API_THROW_ERROR", {apiName: api_name, err: e.message})
+      LoggerService.log(LogLevelEnum::ERROR, "EXECUTION_FAILED", {apiName: api_name, err: e.message, an: ApiEnum::FLUSH_EVENTS})
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vwo-fme-ruby-sdk
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.8.0
 platform: ruby
 authors:
 - VWO
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-12-09 00:00:00.000000000 Z
+date: 2026-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuidtools
@@ -155,6 +155,7 @@ files:
 - lib/vwo/decorators/storage_decorator.rb
 - lib/vwo/enums/api_enum.rb
 - lib/vwo/enums/campaign_type_enum.rb
+- lib/vwo/enums/debug_category_enum.rb
 - lib/vwo/enums/decision_types_enum.rb
 - lib/vwo/enums/event_enum.rb
 - lib/vwo/enums/headers_enum.rb
@@ -207,9 +208,10 @@ files:
 - lib/vwo/services/logger_service.rb
 - lib/vwo/services/settings_service.rb
 - lib/vwo/services/storage_service.rb
-- lib/vwo/utils/batch_event_dispatcher.rb
+- lib/vwo/utils/batch_event_dispatcher_util.rb
 - lib/vwo/utils/campaign_util.rb
 - lib/vwo/utils/data_type_util.rb
+- lib/vwo/utils/debugger_service_util.rb
 - lib/vwo/utils/decision_util.rb
 - lib/vwo/utils/event_util.rb
 - lib/vwo/utils/function_util.rb
@@ -220,7 +222,6 @@ files:
 - lib/vwo/utils/network_util.rb
 - lib/vwo/utils/rule_evaluation_util.rb
 - lib/vwo/utils/settings_util.rb
-- lib/vwo/utils/url_util.rb
 - lib/vwo/utils/usage_stats_util.rb
 - lib/vwo/utils/uuid_util.rb
 - lib/vwo/vwo_builder.rb

data/lib/vwo/utils/url_util.rb

@@ -1,53 +0,0 @@
-# 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.
-
-require_relative '../services/settings_service'
-
-class UrlUtil
-  @collection_prefix = nil
-
-  class << self
-    attr_accessor :collection_prefix
-
-    # Initializes the UrlUtil with an optional collection prefix.
-    #
-    # @param collection_prefix [String] Optional prefix for URL collections.
-    # @return [UrlUtil] The singleton instance of UrlUtil with updated properties.
-    def init(collection_prefix: nil)
-      @collection_prefix = collection_prefix if collection_prefix.is_a?(String)
-      self
-    end
-
-    # Retrieves the base URL.
-    #
-    # @return [String] The base URL.
-    def get_base_url
-      base_url = SettingsService.instance.hostname
-
-      return base_url if SettingsService.instance.is_gateway_service_provided
-
-      # Construct URL with collection_prefix if it exists
-      return "#{base_url}/#{@collection_prefix}" if @collection_prefix
-
-      base_url
-    end
-
-    # Retrieves the collection prefix.
-    #
-    # @return [String] The collection prefix.
-    def get_collection_prefix
-      @collection_prefix
-    end
-  end
-end