vwo-fme-ruby-sdk 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f333409ec82d99443663437007b9b0934fe205e07e1cef53d905c911faf7980
-  data.tar.gz: 7a866f482484ff481d503a90bca9534bbce6832daf99e81a1791a36d0e41e290
+  metadata.gz: 8e0d70f7fcb19c20548cdb55639655c0098f5fa149137014982baafb8bd185e9
+  data.tar.gz: 54c0eab76aef36e5de32fc4953e3cea7add5bbed100d1777c08da18cff900b01
 SHA512:
-  metadata.gz: 0db232a732e10984da13efbc1b47a4e9bb72103a9453da6f910e4c76b43f35b507db4fbd556175e8428c10d9dd17c89fc45b8d097435b1e2133b247d3e101686
-  data.tar.gz: 80119347d3b874637c6af47aa2ee91bdc2fe095a665c4b63de3d8761466e7e587557ad42c24cae879630a06fff211decec14328441fbf0cbf8175ef23ab389a2
+  metadata.gz: e78ca66f6fb6c71e60519658e04362c0b701d81ac3c79ecd18b8ad7aafedce4aec619dac425f1060b4c3f23aec55d43844645be69f998c4a280cd9a0ee70a9b7
+  data.tar.gz: 543ed4464c0e6685a6fa695d5237a573f0553f29f39bd13476451f2ba6e2a4ea21bfe595c01b1aceb356c9ca159e1c739d2f9e33f2eefc3ce9afcb70283c04ab

data/lib/resources/debug_messages.json

@@ -0,0 +1,13 @@
+{
+    "API_CALLED": "API - {apiName} called",
+    "SERVICE_INITIALIZED": "VWO {service} initialized while creating an instance of SDK",
+  
+    "EXPERIMENTS_EVALUATION_WHEN_ROLLOUT_PASSED": "Rollout rule got passed for user {userId}. Hence, evaluating experiments",
+    "EXPERIMENTS_EVALUATION_WHEN_NO_ROLLOUT_PRESENT": "No Rollout rules present for the feature. Hence, checking experiment rules",
+  
+    "USER_BUCKET_TO_VARIATION": "User ID:{userId} for experiment:{campaignKey} having percent traffic:{percentTraffic} got bucket-value:{bucketValue} and hash-value:{hashValue}",
+  
+    "IMPRESSION_FOR_TRACK_USER": "Impression built for vwo_variationShown(VWO standard event for tracking user) event haivng Account ID:{accountId}, User ID:{userId}, and experiment ID:{campaignId}",
+    "IMPRESSION_FOR_TRACK_GOAL": "Impression built for event:{eventName} event having Account ID:{accountId}, and user ID:{userId}",
+    "IMPRESSION_FOR_SYNC_VISITOR_PROP": "Impression built for {eventName}(VWO internal event) event for Account ID:{accountId}, and user ID:{userId}"
+  }

data/lib/resources/error_messages.json

@@ -0,0 +1,30 @@
+{
+    "API_THROW_ERROR": "API - {apiName} failed to execute. Trace:{err}",
+    "INIT_OPTIONS_ERROR": "[ERROR]: VWO-SDK {date} Options should be of type object",
+    "INIT_OPTIONS_SDK_KEY_ERROR": "[ERROR]: VWO-SDK {date} Please provide the sdkKey in the options and should be a of type string",
+    "INIT_OPTIONS_ACCOUNT_ID_ERROR": "[ERROR]: VWO-SDK {date} Please provide VWO account ID in the options and should be a of type string|number",
+  
+    "INIT_OPTIONS_INVALID": "Invalid key:{key} passed in options. Should be of type:{correctType} and greater than equal to 1000",
+  
+    "SETTINGS_FETCH_ERROR": "Settings could not be fetched. Error:{err}",
+    "SETTINGS_SCHEMA_INVALID": "Settings are not valid. Failed schema validation",
+  
+    "POLLING_FETCH_SETTINGS_FAILED": "Error while fetching VWO settings with polling",
+  
+    "API_INVALID_PARAM": "Key:{key} passed to API:{apiName} is not of valid type. Got type:{type}, should be:{correctType}",
+    "API_SETTING_INVALID": "Settings are not valid. Contact VWO Support",
+    "API_CONTEXT_INVALID": "Context should be an object and must contain a mandatory key - id, which is User ID",
+  
+    "FEATURE_NOT_FOUND": "Feature not found for the key:{featureKey}",
+    "EVENT_NOT_FOUND": "Event:{eventName} not found in any of the features' metrics",
+  
+    "STORED_DATA_ERROR": "Error in getting data from storage. Error:{err}",
+    "STORING_DATA_ERROR": "Key:{featureKey} is not valid. Not able to store data into storage",
+  
+    "GATEWAY_URL_ERROR": "Please provide a valid URL for VWO Gateway Service while initializing the SDK",
+  
+    "NETWORK_CALL_FAILED": "Error occurred while sending {method} request. Error:{err}",
+    "SETTINGS_FETCH_FAILED": "Failed to fetch settings and hence VWO client instance couldn't be updated when API: {apiName} got called having isViaWebhook param as {isViaWebhook}. Error: {err}",
+    "NETWORK_CALL_RETRY_ATTEMPT": "Request failed for {endPoint}, Error: {err}. Retrying in {delay} seconds, attempt {attempt} of {maxRetries}",
+    "NETWORK_CALL_RETRY_FAILED": "Max retries reached. Request failed for {endPoint}, Error: {err}"
+  }

data/lib/resources/info_messages.json

@@ -0,0 +1,33 @@
+{
+    "ON_INIT_ALREADY_RESOLVED": "[INFO]: VWO-SDK {date} {apiName} already resolved",
+    "ON_INIT_SETTINGS_FAILED": "[INFO]: VWO-SDK {date} VWO settings could not be fetched",
+  
+    "POLLING_SET_SETTINGS": "There's a change in settings from the last settings fetched. Hence, instantiating a new VWO client internally",
+    "POLLING_NO_CHANGE_IN_SETTINGS": "No change in settings with the last settings fetched. Hence, not instantiating new VWO client",
+  
+    "SETTINGS_FETCH_SUCCESS": "Settings fetched successfully",
+  
+    "CLIENT_INITIALIZED": "VWO Client initialized",
+  
+    "STORED_VARIATION_FOUND": "Variation {variationKey} found in storage for the user {userId} for the {experimentType} experiment:{experimentKey}",
+  
+    "USER_PART_OF_CAMPAIGN": "User ID:{userId} is {notPart} part of experiment:{campaignKey}",
+    "SEGMENTATION_SKIP": "For userId:{userId} of experiment:{campaignKey}, segments was missing. Hence, skipping segmentation",
+    "SEGMENTATION_STATUS": "Segmentation {status} for userId:{userId} of experiment:{campaignKey}",
+  
+    "USER_CAMPAIGN_BUCKET_INFO": "User ID:{userId} for experiment:{campaignKey} {status}",
+  
+    "WHITELISTING_SKIP": "Whitelisting is not used for experiment:{campaignKey}, hence skipping evaluating whitelisting {variation} for User ID:{userId}",
+    "WHITELISTING_STATUS": "User ID:{userId} for experiment:{campaignKey} {status} whitelisting {variationString}",
+  
+    "VARIATION_RANGE_ALLOCATION": "Variation:{variationKey} of experiment:{campaignKey} having weight:{variationWeight} got bucketing range: ({startRange} - {endRange})",
+  
+    "IMPACT_ANALYSIS": "Tracking feature:{featureKey} being {status} for Impact Analysis Campaign for the user {userId}",
+  
+    "MEG_SKIP_ROLLOUT_EVALUATE_EXPERIMENTS": "No rollout rule found for feature:{featureKey}. Hence, evaluating experiments",
+    "MEG_CAMPAIGN_FOUND_IN_STORAGE": "Campaign {campaignKey} found in storage for user ID:{userId}",
+    "MEG_CAMPAIGN_ELIGIBLE": "Campaign {campaignKey} is eligible for user ID:{userId}",
+    "MEG_WINNER_CAMPAIGN": "MEG: Campaign {campaignKey} is the winner for group {groupId} for user ID:{userId} {algo}",
+    "SETTINGS_UPDATED": "Settings fetched and updated successfully on the current VWO client instance when API: {apiName} got called having isViaWebhook param as {isViaWebhook}",
+    "NETWORK_CALL_SUCCESS": "Impression for {event} - {endPoint} was successfully received by VWO having Account ID:{accountId}, User ID:{userId} and UUID: {uuid}"
+  }

data/lib/resources/warn_messages.json

@@ -0,0 +1 @@
+{}

data/lib/vwo/api/get_flag.rb

@@ -0,0 +1,236 @@
+# 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 '../enums/api_enum'
+require_relative '../enums/campaign_type_enum'
+require_relative '../enums/decision_types_enum'
+require_relative '../decorators/storage_decorator'
+require_relative '../services/storage_service'
+require_relative '../models/campaign/feature_model'
+require_relative '../models/campaign/campaign_model'
+require_relative '../packages/segmentation_evaluator/core/segmentation_manager'
+require_relative '../services/logger_service'
+require_relative '../utils/campaign_util'
+require_relative '../utils/rule_evaluation_util'
+require_relative '../utils/impression_util'
+require_relative '../utils/decision_util'
+require_relative '../models/user/get_flag_response'
+
+class FlagApi
+    # Get the flag for a given feature key and context
+    # @param feature_key [String] The key of the feature to get the flag for
+    # @param settings [SettingsModel] The settings for the VWO instance
+    # @param context [ContextModel] The context for the evaluation
+    # @param hooks_service [HooksService] The hooks service for the VWO instance
+    # @return [GetFlagResponse] The flag for the given feature key and context
+    def get(feature_key, settings, context, hooks_service)
+      is_enabled = false
+      rollout_variation_to_return = nil
+      experiment_variation_to_return = nil
+      should_check_for_experiments_rules = false
+  
+      passed_rules_information = {} # for storing integration callback
+      evaluated_feature_map = {}
+
+      # Fetch feature object using the feature key
+      feature = get_feature_from_key(settings, feature_key)
+  
+      decision = {
+        feature_name: feature&.get_name,
+        feature_id: feature&.get_id,
+        feature_key: feature&.get_key,
+        user_id: context&.get_id,
+        api: ApiEnum::GET_FLAG
+      }
+  
+      storage_service = StorageService.new
+      stored_data = StorageDecorator.new.get_feature_from_storage(feature_key, context, storage_service)
+  
+      if stored_data && stored_data[:experiment_variation_id]
+        if stored_data[:experiment_key]
+          variation = CampaignUtil.get_variation_from_campaign_key(settings, stored_data[:experiment_key], stored_data[:experiment_variation_id])
+  
+          if variation
+            LoggerService.log(LogLevelEnum::INFO, "STORED_VARIATION_FOUND", {variationKey: variation.get_key, userId: context.get_id, experimentKey: stored_data[:experiment_key], experimentType: "experiment"})
+            return GetFlagResponse.new(true, variation.get_variables)
+          end
+        end
+      elsif stored_data && stored_data[:rollout_key] && stored_data[:rollout_id]
+        variation = CampaignUtil.get_variation_from_campaign_key(settings, stored_data[:rollout_key], stored_data[:rollout_variation_id])
+  
+        if variation
+          LoggerService.log(LogLevelEnum::INFO, "STORED_VARIATION_FOUND", {variationKey: variation.get_key, userId: context.get_id, experimentKey: stored_data[:rollout_key], experimentType: "rollout"})
+          LoggerService.log(LogLevelEnum::DEBUG, "EXPERIMENTS_EVALUATION_WHEN_ROLLOUT_PASSED", {userId: context.get_id})
+  
+          is_enabled = true
+          should_check_for_experiments_rules = true
+          rollout_variation_to_return = variation
+          feature_info = {
+            rollout_id: stored_data[:rollout_id],
+            rollout_key: stored_data[:rollout_key],
+            rollout_variation_id: stored_data[:rollout_variation_id]
+          }
+          evaluated_feature_map[feature_key] = feature_info
+          passed_rules_information.merge!(feature_info)
+        end
+      end
+  
+      if feature.nil?
+        LoggerService.log(LogLevelEnum::ERROR, "FEATURE_NOT_FOUND", {featureKey: feature_key})
+        return GetFlagResponse.new(false, [])
+      end
+  
+      # Segmentation evaluation
+      SegmentationManager.instance.set_contextual_data(settings, feature, context)
+  
+      # Get all rollout rules
+      rollout_rules = get_specific_rules_based_on_type(feature, CampaignTypeEnum::ROLLOUT)
+  
+      if rollout_rules.any? && !is_enabled
+        rollout_rules_to_evaluate = []
+  
+        rollout_rules.each do |rule|
+          result = evaluate_rule(settings, feature, rule, context, evaluated_feature_map, nil, storage_service, decision)
+          pre_segmentation_result = result[:pre_segmentation_result]
+          updated_decision = result[:updated_decision]
+          decision.merge!(updated_decision) if updated_decision
+  
+          if pre_segmentation_result
+            rollout_rules_to_evaluate << rule
+            evaluated_feature_map[feature_key] = {
+              rollout_id: rule.get_id,
+              rollout_key: rule.get_key,
+              rollout_variation_id: rule.get_variations.first&.get_id
+            }
+            break
+          end
+        end
+  
+        if rollout_rules_to_evaluate.any?
+          passed_rollout_campaign = CampaignModel.new.model_from_dictionary(rollout_rules_to_evaluate.first)
+          variation = DecisionUtil.evaluate_traffic_and_get_variation(settings, passed_rollout_campaign, context.get_id)
+  
+          if variation
+            is_enabled = true
+            should_check_for_experiments_rules = true
+            rollout_variation_to_return = variation
+            update_integrations_decision_object(passed_rollout_campaign, variation, passed_rules_information, decision)
+  
+            create_and_send_impression_for_variation_shown(settings, passed_rollout_campaign.get_id, variation.get_id, context)
+          end
+        end
+      elsif rollout_rules.empty?
+        LoggerService.log(LogLevelEnum::DEBUG, "EXPERIMENTS_EVALUATION_WHEN_NO_ROLLOUT_PRESENT")
+        should_check_for_experiments_rules = true
+      end
+  
+      if should_check_for_experiments_rules
+        experiment_rules = get_all_experiment_rules(feature)
+        experiment_rules_to_evaluate = []
+        meg_group_winner_campaigns = {}
+  
+        experiment_rules.each do |rule|
+          result = evaluate_rule(settings, feature, rule, context, evaluated_feature_map, meg_group_winner_campaigns, storage_service, decision)
+          pre_segmentation_result = result[:pre_segmentation_result]
+          whitelisted_object = result[:whitelisted_object]
+          updated_decision = result[:updated_decision]
+          decision.merge!(updated_decision) if updated_decision
+
+          if pre_segmentation_result
+            if whitelisted_object.nil?
+              experiment_rules_to_evaluate << rule
+            else
+              is_enabled = true
+              experiment_variation_to_return = whitelisted_object[:variation]
+              passed_rules_information.merge!(
+                experiment_id: rule.get_id,
+                experiment_key: rule.get_key,
+                experiment_variation_id: whitelisted_object[:variation_id]
+              )
+            end
+            break
+          end
+        end
+  
+        if experiment_rules_to_evaluate.any?
+          campaign = CampaignModel.new.model_from_dictionary(experiment_rules_to_evaluate.first)
+          variation = DecisionUtil.evaluate_traffic_and_get_variation(settings, campaign, context.get_id)
+  
+          if variation
+            is_enabled = true
+            experiment_variation_to_return = variation
+            update_integrations_decision_object(campaign, variation, passed_rules_information, decision)
+  
+            create_and_send_impression_for_variation_shown(settings, campaign.get_id, variation.get_id, context)
+          end
+        end
+      end
+  
+      # Store evaluated feature in storage
+      if is_enabled
+        StorageDecorator.new.set_data_in_storage(
+          { feature_key: feature_key, context: context }.merge(passed_rules_information),
+          storage_service
+        )
+      end
+  
+      # Execute hooks
+      hooks_service.set(decision)
+      hooks_service.execute(hooks_service.get)
+
+      if feature&.get_impact_campaign&.get_campaign_id
+        LoggerService.log(
+          LogLevelEnum::INFO,
+          "IMPACT_ANALYSIS",
+          {
+            userId: context.get_id,
+            featureKey: feature_key,
+            status: is_enabled ? 'enabled' : 'disabled'
+          }
+        )
+      
+        variation_id = is_enabled ? 2 : 1 # 2 for Variation(flag enabled), 1 for Control(flag disabled)
+        
+        create_and_send_impression_for_variation_shown(
+          settings,
+          feature&.get_impact_campaign&.get_campaign_id,
+          variation_id,
+          context
+        )
+      end
+  
+      # Return final evaluated feature flag
+      return GetFlagResponse.new(is_enabled, experiment_variation_to_return&.get_variables || rollout_variation_to_return&.get_variables || [])
+    end
+  
+    private
+  
+    def update_integrations_decision_object(campaign, variation, passed_rules_information, decision)
+      if campaign.get_type == CampaignTypeEnum::ROLLOUT
+        passed_rules_information.merge!(
+          rollout_id: campaign.get_id,
+          rollout_key: campaign.get_key,
+          rollout_variation_id: variation.get_id
+        )
+      else
+        passed_rules_information.merge!(
+          experiment_id: campaign.get_id,
+          experiment_key: campaign.get_key,
+          experiment_variation_id: variation.get_id
+        )
+      end
+      decision.merge!(passed_rules_information)
+    end
+  end
+  

data/lib/vwo/api/set_attribute.rb

@@ -0,0 +1,57 @@
+# 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/user/context_model'
+require_relative '../enums/event_enum'
+require_relative '../utils/network_util'
+require_relative '../models/settings/settings_model'
+
+class SetAttributeApi
+  # Sets multiple attributes for a user in a single network call.
+  # @param settings [SettingsModel] Configuration settings.
+  # @param attributes [Hash] Key-value map of attributes.
+  # @param context [ContextModel] Context containing user information.
+  def set_attribute(settings, attributes, context)
+    create_impression_for_attributes(settings, attributes, context)
+  end
+
+  private
+
+  # Creates an impression for multiple user attributes and sends it to the server.
+  # @param settings [SettingsModel] Configuration settings.
+  # @param attributes [Hash] Key-value map of attributes.
+  # @param context [ContextModel] Context containing user information.
+  def create_impression_for_attributes(settings, attributes, context)
+    # Retrieve base properties for the event
+    properties = NetworkUtil.get_events_base_properties(
+      settings,
+      EventEnum::VWO_SYNC_VISITOR_PROP,
+      URI.encode_www_form_component(context.user_agent),
+      context.ip_address
+    )
+
+    # Construct payload data for multiple attributes
+    payload = NetworkUtil.get_attribute_payload_data(
+      settings,
+      context.id,
+      EventEnum::VWO_SYNC_VISITOR_PROP,
+      attributes,
+      context.user_agent,
+      context.ip_address
+    )
+
+    # Send the constructed payload via POST request
+    NetworkUtil.send_post_api_request(properties, payload)
+  end
+end

data/lib/vwo/api/track_event.rb

@@ -0,0 +1,77 @@
+# 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 '../enums/api_enum'
+require_relative '../models/settings/settings_model'
+require_relative '../models/user/context_model'
+require_relative '../services/hooks_service'
+require_relative '../utils/function_util'
+require_relative '../utils/network_util'
+require_relative '../services/logger_service'
+class TrackApi
+  # Tracks an event with given properties and context.
+  # @param settings [SettingsModel] Configuration settings.
+  # @param event_name [String] Name of the event to track.
+  # @param context [ContextModel] Contextual information like user details.
+  # @param event_properties [Hash] Properties associated with the event.
+  # @param hooks_service [HooksService] Manager for handling hooks and callbacks.
+  # @return [Hash] A hash indicating success or failure of event tracking.
+  def track(settings, event_name, context, event_properties, hooks_service)
+    if does_event_belong_to_any_feature(event_name, settings)
+      # Create an impression for the track event
+      create_impression_for_track(settings, event_name, context, event_properties)
+
+      # Set and execute integration callback for the track event
+      hooks_service.set({ event_name: event_name, api: ApiEnum::TRACK })
+      hooks_service.execute(hooks_service.get)
+
+      return { event_name: true }
+    end
+
+    # Log an error if the event does not exist
+    LoggerService.log(LogLevelEnum::ERROR, "EVENT_NOT_FOUND", { eventName: event_name })
+
+    { event_name: false }
+  end
+
+  private
+
+  # Creates an impression for a track event and sends it via a POST API request.
+  # @param settings [SettingsModel] Configuration settings.
+  # @param event_name [String] Name of the event to track.
+  # @param context [ContextModel] User details.
+  # @param event_properties [Hash] Properties associated with the event.
+  def create_impression_for_track(settings, event_name, context, event_properties)
+    # Get base properties for the event
+    properties = NetworkUtil.get_events_base_properties(
+      settings,
+      event_name,
+      URI.encode_www_form_component(context.user_agent),
+      context.ip_address
+    )
+
+    # Prepare the payload for the track goal
+    payload = NetworkUtil.get_track_goal_payload_data(
+      settings,
+      context.id,
+      event_name,
+      event_properties,
+      context.user_agent,
+      context.ip_address
+    )
+
+    # Send the prepared payload via POST API request
+    NetworkUtil.send_post_api_request(properties, payload)
+  end
+end

data/lib/vwo/constants/constants.rb

@@ -0,0 +1,54 @@
+# 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.
+
+# Constants file for Ruby SDK
+
+# Define the Constants module
+module Constants
+  SDK_NAME = 'vwo-fme-ruby-sdk'.freeze
+  SDK_VERSION = '1.2.0'.freeze
+
+  MAX_TRAFFIC_PERCENT = 100
+  MAX_TRAFFIC_VALUE = 10_000
+  STATUS_RUNNING = 'RUNNING'.freeze
+
+  SEED_VALUE = 1
+  MAX_EVENTS_PER_REQUEST = 5_000
+  DEFAULT_REQUEST_TIME_INTERVAL = 600 # 10 minutes in seconds
+  DEFAULT_EVENTS_PER_REQUEST = 100
+
+  SEED_URL = 'https://vwo.com'.freeze  # Define SEED_URL
+  HTTP_PROTOCOL = 'http'.freeze
+  HTTPS_PROTOCOL = 'https'.freeze
+
+  SETTINGS = 'settings'.freeze
+  SETTINGS_EXPIRY = 10_000_000
+  SETTINGS_TIMEOUT = 50_000
+
+  HOST_NAME = 'dev.visualwebsiteoptimizer.com'.freeze
+  SETTINGS_ENDPOINT = '/server-side/v2-settings'.freeze
+  WEBHOOK_SETTINGS_ENDPOINT = '/server-side/v2-pull'.freeze
+  LOCATION_ENDPOINT = '/getLocation'.freeze
+
+  VWO_FS_ENVIRONMENT = 'vwo_fs_environment'.freeze
+
+  RANDOM_ALGO = 1
+
+  API_VERSION = '1'.freeze
+
+  VWO_META_MEG_KEY = '_vwo_meta_meg_'.freeze
+
+  SHOULD_USE_THREADING = true
+  MAX_POOL_SIZE = 5
+end

data/lib/vwo/decorators/storage_decorator.rb

@@ -0,0 +1,86 @@
+# 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 '../enums/storage_enum'
+require_relative '../models/campaign/feature_model'
+require_relative '../models/campaign/variation_model'
+require_relative '../services/storage_service'
+require_relative '../models/user/context_model'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+class StorageDecorator
+  # Retrieves a feature from storage based on the feature key and user.
+  # @param feature_key [String] The key of the feature to retrieve.
+  # @param context [ContextModel] The user object.
+  # @param storage_service [StorageService] The storage service instance.
+  # @return [Hash, StorageEnum] The retrieved feature or relevant status.
+  def get_feature_from_storage(feature_key, context, storage_service)
+    campaign_map = storage_service.get_data_from_storage(feature_key, context)
+
+    case campaign_map
+    when StorageEnum::STORAGE_UNDEFINED, StorageEnum::NO_DATA_FOUND,
+         StorageEnum::CAMPAIGN_PAUSED, StorageEnum::WHITELISTED_VARIATION
+      nil # Return nil when there's no valid data
+    when StorageEnum::INCORRECT_DATA, StorageEnum::VARIATION_NOT_FOUND
+      campaign_map # Return the relevant error constant
+    else
+      campaign_map # Return valid stored data
+    end
+  end
+
+  # Sets data in storage based on the provided data object.
+  # @param data [Hash] The data to be stored, including feature key and user details.
+  # @param storage_service [StorageService] The storage service instance.
+  def set_data_in_storage(data, storage_service)
+    feature_key = data[:feature_key]
+    context = data[:context]
+    rollout_id = data[:rollout_id]
+    rollout_key = data[:rollout_key]
+    rollout_variation_id = data[:rollout_variation_id]
+    experiment_id = data[:experiment_id]
+    experiment_key = data[:experiment_key]
+    experiment_variation_id = data[:experiment_variation_id]
+
+    if feature_key.nil?
+      LoggerService.log(LogLevelEnum::ERROR, "STORING_DATA_ERROR", { key: 'featureKey' })
+      raise 'Feature key is missing'
+    end
+
+    if context.nil? || context.id.nil?
+      LoggerService.log(LogLevelEnum::ERROR, "STORING_DATA_ERROR", { key: 'Context or Context.id' })
+      raise 'Context ID is missing'
+    end
+
+    if rollout_key && !experiment_key && !rollout_variation_id
+      LoggerService.log(LogLevelEnum::ERROR, "STORING_DATA_ERROR", { key: 'Variation:(rolloutKey, experimentKey or rolloutVariationId)' })
+      raise 'Invalid rollout variation'
+    end
+
+    if experiment_key && !experiment_variation_id
+      LoggerService.log(LogLevelEnum::ERROR, "STORING_DATA_ERROR", { key: 'Variation:(experimentKey or rolloutVariationId)' })
+      raise 'Invalid experiment variation'
+    end
+
+    storage_service.set_data_in_storage({
+      feature_key: feature_key,
+      user_id: context.id,
+      rollout_id: rollout_id,
+      rollout_key: rollout_key,
+      rollout_variation_id: rollout_variation_id,
+      experiment_id: experiment_id,
+      experiment_key: experiment_key,
+      experiment_variation_id: experiment_variation_id
+    })
+  end
+end

data/lib/vwo/{utils/logger_helper.rb → enums/api_enum.rb}

@@ -1,4 +1,4 @@
-# Copyright 2024 Wingify Software Pvt. Ltd.
+# 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.
@@ -12,13 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'logger'
-
-module LoggerHelper
-  # Singleton logger instance
-  def self.logger
-    @logger ||= Logger.new(STDOUT)  # You can log to a file like 'application.log'
-    @logger.level = Logger::DEBUG    # Set the default logging level
-    @logger
+module ApiEnum
+    GET_FLAG = 'getFlag'
+    TRACK = 'track'
   end
-end
+  

data/lib/vwo/enums/campaign_type_enum.rb

@@ -0,0 +1,19 @@
+# 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.
+
+module CampaignTypeEnum
+    ROLLOUT = 'FLAG_ROLLOUT'
+    AB = 'FLAG_TESTING'
+    PERSONALIZE = 'FLAG_PERSONALIZE'
+  end

data/lib/vwo/enums/decision_types_enum.rb

@@ -0,0 +1,18 @@
+# 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.
+
+module DecisionTypes
+    CAMPAIGN_DECISION = 'CAMPAIGN_DECISION'
+  end
+