Class: FlagApi

Inherits:

Object

• Object
• FlagApi

Defined in:

lib/wingify/api/get_flag.rb

Instance Method Summary

• #get(feature_key, settings, context, hooks_service) ⇒ GetFlagResponse

  Get the flag for a given feature key and context.

Instance Method Details

#get(feature_key, settings, context, hooks_service) ⇒ GetFlagResponse

Get the flag for a given feature key and context

Parameters:

• feature_key (String) —

  The key of the feature to get the flag for

• settings (SettingsModel) —

  The settings for the VWO instance

• context (ContextModel) —

  The context for the evaluation

• hooks_service (HooksService) —

  The hooks service for the VWO instance

Returns:

• (GetFlagResponse) —

  The flag for the given feature key and context

# File 'lib/wingify/api/get_flag.rb', line 38

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
  # Flag to check if variation shown event has been fired
  is_variation_shown_fired = false
  # Flag to check if tracking usage is enabled
  is_tracking_usage_enabled = settings.get_is_tracking_usage_enabled
  
  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"})
          # Send usage tracking call when user is served from storage
          send_tracking_usage(settings, context, is_tracking_usage_enabled, feature_key)
          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})
    # Send usage tracking call when feature is not found
    send_tracking_usage(settings, context, is_tracking_usage_enabled, feature_key)
    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]
      whitelisted_object = result[:whitelisted_object]
      
      if whitelisted_object.is_a?(Hash) && !whitelisted_object.empty?
        is_variation_shown_fired = true
      end

      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)
        # set is_variation_shown_fired to true since we already sent variation shown call for rollout
        is_variation_shown_fired = true
      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]
      
      if whitelisted_object.is_a?(Hash) && !whitelisted_object.empty?
        is_variation_shown_fired = true
      end

      updated_decision = result[:updated_decision]
      decision.merge!(updated_decision) if updated_decision

      if pre_segmentation_result
        if whitelisted_object.nil? || whitelisted_object.empty?
          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)
        # set is_variation_shown_fired to true since we already sent variation shown call for experiment
        is_variation_shown_fired = true
      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
    )
    # set is_variation_shown_fired to true since we already sent variation shown call for impact analysis
    is_variation_shown_fired = true
  end

  # Send usage tracking call when no primary variation_shown event was dispatched.
  # If a primary variation_shown event was fired, the server already has the usage tracking signal.
  if !is_variation_shown_fired
    send_tracking_usage(settings, context, is_tracking_usage_enabled, 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