wingify-fme-ruby-sdk 1.50.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ae10f6a02b6a5ddb698aed1f7ac3eb5461678e016dbd0e7084668bca8bcd0f62
+  data.tar.gz: ff5cae6fb46441e45f5b50fa1a8ce0149a356b622b41c0da7fedde092c75f87e
+SHA512:
+  metadata.gz: 06aaf6ca460223d50c225308579926ce7349142606a7d9ff3fc3a758d3c2d43a79276dcc02e7bf5c16c2915e76368442049f4b1fed011bbe650b2d10ed1d8ba1
+  data.tar.gz: ea43e8123d418bba625bf55dffed678713bc1513c90895aa60cce177ca77959ce460f919da56cc1bb1ce58d2ee8287c9274ee7f15399ddb974eefdd9d4700677

data/lib/resources/debug_messages.json

@@ -0,0 +1,21 @@
+{
+    "API_CALLED": "API - {apiName} called",
+    "SERVICE_INITIALIZED": "{brand} {service} initialized while creating an instance of SDK",
+    "USING_POLL_INTERVAL_FROM_SETTINGS": "key: poll_interval not found or invalid. Using poll_interval from {source} ({pollInterval})",
+  
+    "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({brand} 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}({brand} internal event) event for Account ID:{accountId}, and user ID:{userId}",
+
+    "CONFIG_BATCH_EVENT_LIMIT_EXCEEDED": "Impression event - {endPoint} failed due to exceeding payload size. Parameter eventsPerRequest in batchEvents config in init API has value:{eventsPerRequest} for account ID:{accountId}. Please read the official documentation for knowing the size limits",
+
+    "EVENT_BATCH_BEFORE_FLUSHING": "Flushing event queue {manually} having {length} events for Account ID:{accountId}. {timer}",
+    "EVENT_BATCH_FLUSH": "Manually flushing batch events for Account ID:{accountId} having {queueLength} events",
+    "BATCH_QUEUE_EMPTY": "Batch queue is empty. Nothing to flush.",
+    "WEB_UUID_FOUND": "VWO Web Testing identified UUID {uuid} as the Context ID for API {apiName}"
+  }

data/lib/resources/error_messages.json

@@ -0,0 +1,63 @@
+{
+    "EXECUTION_FAILED": "API - {apiName} failed to execute. Error:{err}",
+    "INVALID_OPTIONS": "[ERROR]: {log_prefix} {date} Options should be of type object",
+    "INVALID_SDK_KEY_IN_OPTIONS": "[ERROR]: {log_prefix} {date} Please provide the sdkKey in the options and should be a of type string",
+    "INVALID_ACCOUNT_ID_IN_OPTIONS": "[ERROR]: {log_prefix} {date} Please provide {brand} account ID in the options and should be a of type string|number",
+
+    "ERROR_ADDING_CAMPAIGNS_TO_RULES": "Error setting and adding campaigns to rules. Error: {err}",
+  
+    "INVALID_POLLING_CONFIGURATION": "Invalid key:{key} passed in options. Should be of type:{correctType} and greater than or equal to 1000",
+  
+    "ERROR_FETCHING_SETTINGS": "Settings could not be fetched. Error:{err}",
+    "INVALID_SETTINGS_SCHEMA": "Settings are not valid for account ID: {accountId} and SDK key: {sdkKey}. Got settings as {settings}",
+  
+    "ERROR_UPDATING_SETTINGS": "Error while updating settings. Error: {err}",
+    "UPDATING_CLIENT_INSTANCE_FAILED_WHEN_WEBHOOK_TRIGGERED": "Failed to fetch settings and hence {brand} client instance couldn't be updated when API: {apiName} got called having isViaWebhook param as {isViaWebhook}. Error: {err}",
+  
+    "INVALID_PARAM": "Key:{key} passed to API:{apiName} is not of valid type. Got type:{type}, should be:{correctType}",
+    "INVALID_CONTEXT": "Context should be an object and must contain a mandatory key - id, which is User ID",
+    "INVALID_BUCKETING_SEED": "bucketingSeed passed to API:{apiName} is invalid (got type:{type}). It must be a non-empty string. Falling back to userId for bucketing.",
+  
+    "FEATURE_NOT_FOUND": "Feature not found for the key:{featureKey}",
+    "EVENT_NOT_FOUND": "Event:{eventName} not found in any of the features' metrics",
+  
+    "ERROR_READING_DATA_FROM_STORAGE": "Error while reading data from storage. Error: {err}",
+    "ERROR_STORING_DATA_IN_STORAGE": "Error while storing data in storage. Error: {err}",
+  
+    "INVALID_GATEWAY_URL": "Please provide a valid URL for {brand} Gateway Service while initializing the SDK",
+    "INVALID_RETRY_CONFIG": "Retry config is invalid. Should be of type:object",
+  
+    "NETWORK_CALL_FAILED": "Error occurred for {method} request. 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}",
+    "ATTEMPTING_RETRY_FOR_FAILED_NETWORK_CALL": "Request failed for {endPoint}, Error: {err}. Retrying in {delay} seconds, attempt {attempt} of {maxRetries}",
+    "NETWORK_CALL_FAILURE_AFTER_MAX_RETRIES": "Network request failed after {attempts} attempts for {extraData}. Error: {err}",
+
+    "BATCH_QUEUE_EMPTY": "No batch queue present for account:{accountId} when calling flushEvents API. Check batchEvents config in init API",
+    "INVALID_BATCH_EVENTS_CONFIG": "Invalid batch events config, should be a hash, events_per_request should be a number greater than 0 and request_time_interval should be a number greater than 0",
+    "FAILED_TO_INITIALIZE_SERVICE": "Failed to initialize {service}: {err}",
+
+    "ERROR_SETTING_SEGMENTATION_CONTEXT": "Error in setting contextual data for segmentation. Got error: {err}",
+    "ERROR_VALIDATING_SEGMENTATION": "Error in validating segmentation. Got error: {err}",
+    "USER_AGENT_VALIDATION_ERROR": "Failed to validate user agent. Error: {err}",
+    "INVALID_IP_ADDRESS_IN_CONTEXT_FOR_PRE_SEGMENTATION": "ipAddress is required in context to evaluate location pre-segmentation",
+    "INVALID_USER_AGENT_IN_CONTEXT_FOR_PRE_SEGMENTATION": "userAgent is required in context to evaluate user-agent pre-segmentation",
+    "INVALID_ATTRIBUTE_LIST_FORMAT": "Invalid inList operand format",
+    "ERROR_FETCHING_DATA_FROM_GATEWAY": "Error while fetching data from gateway. Error: {err}",
+
+    "ATTRIBUTES_MAP_ERROR": "Attributes map must contain atleast 1 key-value pair",
+    "ATTRIBUTES_MAP_INVALID": "Attributes should be an object containing key-value pairs",
+
+    "VALUES_MISMATCH_BATCHING_NOT_ENABLED": "Values mismatch from the expectation of both parameters. Batching not initialized.",
+    "INVALID_EVENTS_PER_REQUEST_VALUE": "Events_per_request values is invalid (should be greater than 0 and less than 5000). Using default value of events_per_request parameter : 100",
+    "INVALID_REQUEST_TIME_INTERVAL_VALUE": "Request_time_interval values is invalid (should be greater than 0). Using default value of request_time_interval parameter : 600",
+    "BATCHING_NOT_ENABLED": "Batching is not enabled. Pass batchEventData in the SDK configuration while invoking init API.",
+
+    "ERROR_CHECKING_FEATURE_IN_USER_STORAGE": "Error while checking feature in user storage. Got error: {err}",
+
+    "ERROR_FINDING_WINNER_CAMPAIGN": "Error while finding winner campaign inside {method}. Error: {err}",
+
+    "ERROR_EVALUATING_RULE": "Error occurred while evaluating rule. Error: {err}",
+    "BATCH_FLUSH_FAILED": "Failed to send batch events. Re-enqueuing events for retry.",
+    "ERROR_PARSING_GATEWAY_URL": "Error occurred while parsing gateway service URL: {err}"
+  }

data/lib/resources/info_messages.json

@@ -0,0 +1,43 @@
+{
+    "ON_INIT_ALREADY_RESOLVED": "[INFO]: {log_prefix} {date} {apiName} already resolved",
+    "ON_INIT_SETTINGS_FAILED": "[INFO]: {log_prefix} {date} {brand} settings could not be fetched",
+  
+    "POLLING_SET_SETTINGS": "There's a change in settings from the last settings fetched. Hence, instantiating a new {brand} client internally",
+    "POLLING_NO_CHANGE_IN_SETTINGS": "No change in settings with the last settings fetched. Hence, not instantiating new {brand} client",
+  
+    "SETTINGS_FETCH_SUCCESS": "Settings fetched successfully",
+  
+    "CLIENT_INITIALIZED": "{brand} 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 {brand} client instance when API: {apiName} got called having isViaWebhook param as {isViaWebhook}",
+    "NETWORK_CALL_SUCCESS": "Impression for {event} - {endPoint} was successfully received by {brand} having Account ID:{accountId}, UUID: {uuid}",
+
+    "EVENT_BATCH_DEFAULTS": "{parameter} in SDK configuration is missing or invalid (should be greater than {minLimit}). Using default value: {defaultValue}",
+    "EVENT_QUEUE": "Event with payload:{event} pushed to the {queueType} queue",
+    "EVENT_BATCH_After_FLUSHING": "Event queue having {length} events has been flushed {manually}",
+    "IMPRESSION_BATCH_SUCCESS": "Impression event - {endPoint} was successfully received by {brand} having Account ID:{accountId}",
+    "IMPRESSION_BATCH_FAILED": "Batch events couldn\"t be received by {brand}. Calling Flush Callback with error and data",
+    "EVENT_BATCH_MAX_LIMIT": "{parameter} passed in SDK configuration is greater than the maximum limit of {maxLimit}. Setting it to the maximum limit",
+    "GATEWAY_AND_BATCH_EVENTS_CONFIG_MISMATCH": "Batch Events config passed in SDK configuration will not work as the gatewayService is already configured. Please check the documentation for more details",
+    "NETWORK_CALL_SUCCESS_WITH_RETRIES": "Network call for {extraData} succeeded after {attempts} retry attempt(s). Previous attempts failed with error: {err}",
+    "PROXY_AND_GATEWAY_SERVICE_PROVIDED": "Both proxy URL and gateway service are provided. Gateway service will be used and proxy URL will be ignored"
+  }

data/lib/resources/warn_messages.json

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

data/lib/vwo.rb

@@ -0,0 +1,40 @@
+# 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 'wingify'
+require_relative 'wingify/wingify_client'
+require_relative 'wingify/wingify_builder'
+
+# Map existing VWO classes to Wingify aliases to maintain 100% backward compatibility
+VWOClient = WingifyClient
+VWOBuilder = WingifyBuilder
+
+module VWO
+  # Backward compatible VWO facade
+  # It intercepts the init call, forces the is_via_vwo flag, and forwards to Wingify core.
+  def self.init(options)
+    options[:is_via_vwo] = true
+    Wingify.init(options)
+  end
+
+  def self.get_uuid(user_id, account_id)
+    Wingify.get_uuid(user_id, account_id)
+  end
+
+  # Keep VWO.new backward compatible for any customers manually instantiating it,
+  # although standard docs recommend VWO.init
+  def self.new(options)
+    init(options)
+  end
+end

data/lib/wingify/api/get_flag.rb

@@ -0,0 +1,244 @@
+# 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/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'
+require_relative '../packages/storage/storage'
+
+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
+      if Storage.instance.is_storage_enabled
+        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, context.get_uuid, context.get_session_id)
+            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
+      end
+  
+      if feature.nil?
+        LoggerService.log(LogLevelEnum::ERROR, "FEATURE_NOT_FOUND", {featureKey: feature_key, an: ApiEnum::GET_FLAG, sId: context.get_session_id, uuid: context.get_uuid})
+        return GetFlagResponse.new(false, [], context.get_uuid, context.get_session_id)
+      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)
+  
+          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, feature_key)
+          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)
+  
+          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, feature_key)
+          end
+        end
+      end
+  
+      # Store evaluated feature in storage
+      if is_enabled
+        begin
+          StorageDecorator.new.set_data_in_storage(
+            { feature_key: feature_key, context: context }.merge(passed_rules_information),
+            storage_service
+          )
+        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})
+        end
+      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,
+          feature_key
+        )
+      end
+  
+      # Return final evaluated feature flag
+      return GetFlagResponse.new(is_enabled, experiment_variation_to_return&.get_variables || rollout_variation_to_return&.get_variables || [], context.get_uuid, context.get_session_id)
+    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/wingify/api/set_attribute.rb

@@ -0,0 +1,57 @@
+# 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/user/context_model'
+require_relative '../enums/event_enum'
+require_relative '../utils/network_util'
+require_relative '../services/batch_event_queue'
+
+class SetAttributeApi
+  # Sets multiple attributes for a user in a single network call.
+  # @param attributes [Hash] Key-value map of attributes.
+  # @param context [ContextModel] Context containing user information.
+  def set_attribute(attributes, context)
+    create_impression_for_attributes(attributes, context)
+  end
+
+  private
+
+  # Creates an impression for multiple user attributes and sends it to the server.
+  # @param attributes [Hash] Key-value map of attributes.
+  # @param context [ContextModel] Context containing user information.
+  def create_impression_for_attributes(attributes, context)
+    # Retrieve base properties for the event
+    properties = NetworkUtil.get_events_base_properties(
+      EventEnum::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(
+      EventEnum::SYNC_VISITOR_PROP,
+      attributes,
+      context
+    )
+
+    # check if batching is enabled
+    if BatchEventsQueue.instance
+      # add the payload to the batch events queue
+      BatchEventsQueue.instance.enqueue(payload)
+    else
+      # Send the constructed payload via POST request
+      NetworkUtil.send_post_api_request(properties, payload)
+    end
+  end
+end

data/lib/wingify/api/track_event.rb

@@ -0,0 +1,80 @@
+# 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/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'
+require_relative '../services/batch_event_queue'
+
+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(event_name, context, event_properties)
+
+      # Set and execute integration callback for the track event
+      hooks_service.set({ event_name: event_name, api: ApiEnum::TRACK_EVENT })
+      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, an: ApiEnum::TRACK_EVENT, sId: context.get_session_id, uuid: context.get_uuid})
+
+    { event_name: false }
+  end
+
+  private
+
+  # Creates an impression for a track event and sends it via a POST API request.
+  # @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(event_name, context, event_properties)
+    # Get base properties for the event
+    properties = NetworkUtil.get_events_base_properties(
+      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(
+      event_name,
+      event_properties,
+      context
+    )
+
+    # check if batching is enabled
+    if BatchEventsQueue.instance
+      # add the payload to the batch events queue
+      BatchEventsQueue.instance.enqueue(payload)
+    else
+      # Send the prepared payload via POST API request
+      NetworkUtil.send_post_api_request(properties, payload)
+    end
+  end
+end