vwo-fme-ruby-sdk 1.0.0 → 1.1.0

data/lib/vwo/packages/segmentation_evaluator/evaluators/segment_operand_evaluator.rb

@@ -0,0 +1,198 @@
+# 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 '../utils/segment_util'
+require_relative '../enums/segment_operand_value_enum'
+require_relative '../enums/segment_operand_regex_enum'
+require_relative '../../../utils/data_type_util'
+require_relative '../../../utils/gateway_service_util'
+require_relative '../../../enums/url_enum'
+require_relative '../../../services/logger_service'
+require_relative '../../../models/user/context_model'
+require_relative '../../../enums/log_level_enum'
+class SegmentOperandEvaluator
+  # Evaluates the custom variable DSL
+  # @param dsl_operand_value [String] The operand value to evaluate
+  # @param properties [Hash] The properties to evaluate the operand against
+  # @return [Boolean] True if the operand value matches the tag value, false otherwise
+  def evaluate_custom_variable_dsl(dsl_operand_value, properties)
+    key_value = get_key_value(dsl_operand_value)
+    return false unless key_value
+
+    operand_key = key_value[:key].to_sym
+    operand = key_value[:value]
+
+    return false unless properties.key?(operand_key)
+
+    if operand.include?('inlist')
+      match = operand.match(/inlist\(([^)]+)\)/)
+      unless match
+        LoggerService.log(LogLevelEnum::ERROR, "Invalid 'inList' operand format", nil)
+        return false
+      end
+
+      tag_value = pre_process_tag_value(properties[operand_key])
+      list_id = match[1]
+
+      query_params_obj = { attribute: tag_value, listId: list_id }
+
+      begin
+        res = get_from_gateway_service(query_params_obj, UrlEnum::ATTRIBUTE_CHECK)
+        if res.nil? || res == false || res == 'false' || (res.is_a?(Hash) && res[:status] == 0)
+          return false
+        end
+        return res
+      rescue StandardError => e
+        LoggerService.log(LogLevelEnum::ERROR, "Error while fetching data: #{e}", nil)
+        return false
+      end
+
+      false
+    else
+      tag_value = pre_process_tag_value(properties[operand_key])
+      processed_values = process_values(*pre_process_operand_value(operand), tag_value)
+      extract_result(processed_values[:operand_type], processed_values[:operand_value], processed_values[:tag_value])
+    end
+  end
+
+  # Evaluates the user DSL
+  # @param dsl_operand_value [String] The operand value to evaluate
+  # @param properties [Hash] The properties to evaluate the operand against
+  # @return [Boolean] True if the operand value matches the tag value, false otherwise
+  def evaluate_user_dsl(dsl_operand_value, properties)
+    users = dsl_operand_value.split(',')
+    users.any? { |user| user.strip == properties["_vwoUserId"].to_s }
+  end
+
+  # Evaluates the user agent DSL
+  # @param dsl_operand_value [String] The operand value to evaluate
+  # @param context [ContextModel] The context to evaluate the operand against
+  # @return [Boolean] True if the operand value matches the tag value, false otherwise
+  def evaluate_user_agent_dsl(dsl_operand_value, context)
+    return false unless context.get_user_agent
+
+    tag_value = CGI.unescape(context.get_user_agent)
+    processed_values = process_values(*pre_process_operand_value(dsl_operand_value), tag_value)
+    extract_result(processed_values[:operand_type], processed_values[:operand_value], processed_values[:tag_value])
+  end
+
+  # Pre-processes the tag value
+  # @param tag_value [String] The tag value to pre-process
+  # @return [String] The pre-processed tag value
+  def pre_process_tag_value(tag_value)
+    return '' if tag_value.nil?
+    return tag_value if [true, false].include?(tag_value)
+
+    tag_value.to_s
+  end
+
+  # Pre-processes the operand value
+  # @param operand [String] The operand to pre-process
+  # @return [Hash] The pre-processed operand value
+  def pre_process_operand_value(operand)
+    case operand
+    when /#{SegmentOperandRegexEnum::LOWER_MATCH}/
+      { operand_type: SegmentOperandValueEnum::LOWER_VALUE, operand_value: extract_operand_value(operand, SegmentOperandRegexEnum::LOWER_MATCH) }
+    when /#{SegmentOperandRegexEnum::WILDCARD_MATCH}/
+      value = extract_operand_value(operand, SegmentOperandRegexEnum::WILDCARD_MATCH)
+      if value.match?(SegmentOperandRegexEnum::STARTING_STAR) && value.match?(SegmentOperandRegexEnum::ENDING_STAR)
+        type = SegmentOperandValueEnum::STARTING_ENDING_STAR_VALUE
+        value = value.gsub(/^\*|\*$/, '')
+      elsif value.match?(SegmentOperandRegexEnum::STARTING_STAR)
+        type = SegmentOperandValueEnum::STARTING_STAR_VALUE
+        value = value.gsub(/^\*/, '')
+      elsif value.match?(SegmentOperandRegexEnum::ENDING_STAR)
+        type = SegmentOperandValueEnum::ENDING_STAR_VALUE
+        value = value.gsub(/\*$/, '')
+      end
+      { operand_type: type, operand_value: value }
+    when /#{SegmentOperandRegexEnum::REGEX_MATCH}/
+      { operand_type: SegmentOperandValueEnum::REGEX_VALUE, operand_value: extract_operand_value(operand, SegmentOperandRegexEnum::REGEX_MATCH) }
+    when /#{SegmentOperandRegexEnum::GREATER_THAN_MATCH}/
+      { operand_type: SegmentOperandValueEnum::GREATER_THAN_VALUE, operand_value: extract_operand_value(operand, SegmentOperandRegexEnum::GREATER_THAN_MATCH) }
+    when /#{SegmentOperandRegexEnum::LESS_THAN_MATCH}/
+      { operand_type: SegmentOperandValueEnum::LESS_THAN_VALUE, operand_value: extract_operand_value(operand, SegmentOperandRegexEnum::LESS_THAN_MATCH) }
+    when /#{SegmentOperandRegexEnum::GREATER_THAN_EQUAL_TO_MATCH}/
+      { operand_type: SegmentOperandValueEnum::GREATER_THAN_EQUAL_TO_VALUE, operand_value: extract_operand_value(operand, SegmentOperandRegexEnum::GREATER_THAN_EQUAL_TO_MATCH) }
+    when /#{SegmentOperandRegexEnum::LESS_THAN_EQUAL_TO_MATCH}/
+      { operand_type: SegmentOperandValueEnum::LESS_THAN_EQUAL_TO_VALUE, operand_value: extract_operand_value(operand, SegmentOperandRegexEnum::LESS_THAN_EQUAL_TO_MATCH) }
+    else
+      { operand_type: SegmentOperandValueEnum::EQUAL_VALUE, operand_value: operand }
+    end
+  end
+
+  # Extracts the operand value from the operand
+  # @param operand [String] The operand to extract the value from
+  # @param regex [String] The regex to match the operand against
+  # @return [String] The extracted operand value
+  def extract_operand_value(operand, regex)
+    match = operand.match(/#{regex}/)
+    match ? match[1] : ''
+  end
+
+  # Processes the values from the operand and tag value
+  # @param operand_type [Symbol] The type of operand
+  # @param operand_value [String] The value of the operand
+  # @param tag_value [String] The value of the tag
+  # @return [Hash] The processed operand value and tag value
+  def process_values(operand_type, operand_value, tag_value)
+    # Extract values from arrays if needed
+    operand_type = operand_type[1] if operand_type.is_a?(Array)
+    operand_value = operand_value[1] if operand_value.is_a?(Array)
+    tag_value = tag_value[1] if tag_value.is_a?(Array)
+
+    processed_operand_value = operand_value.to_f
+    processed_tag_value = tag_value.to_f
+
+    if processed_operand_value == 0 || processed_tag_value == 0
+      return { operand_type: operand_type, operand_value: operand_value, tag_value: tag_value }
+    end
+
+    { operand_type: operand_type, operand_value: processed_operand_value.to_s, tag_value: processed_tag_value.to_s }
+  end
+
+  # Extracts the result from the operand value and tag value
+  # @param operand_type [Symbol] The type of operand
+  # @param operand_value [String] The value of the operand
+  # @param tag_value [String] The value of the tag
+  # @return [Boolean] True if the operand value matches the tag value, false otherwise
+  def extract_result(operand_type, operand_value, tag_value)
+    case operand_type
+    when SegmentOperandValueEnum::LOWER_VALUE
+      operand_value.downcase == tag_value.downcase
+    when SegmentOperandValueEnum::STARTING_ENDING_STAR_VALUE
+      tag_value.include?(operand_value)
+    when SegmentOperandValueEnum::STARTING_STAR_VALUE
+      tag_value.end_with?(operand_value)
+    when SegmentOperandValueEnum::ENDING_STAR_VALUE
+      tag_value.start_with?(operand_value)
+    when SegmentOperandValueEnum::REGEX_VALUE
+      begin
+        !!Regexp.new(operand_value).match?(tag_value)
+      rescue StandardError
+        false
+      end
+    when SegmentOperandValueEnum::GREATER_THAN_VALUE
+      operand_value.to_f < tag_value.to_f
+    when SegmentOperandValueEnum::LESS_THAN_VALUE
+      operand_value.to_f > tag_value.to_f
+    when SegmentOperandValueEnum::GREATER_THAN_EQUAL_TO_VALUE
+      operand_value.to_f <= tag_value.to_f
+    when SegmentOperandValueEnum::LESS_THAN_EQUAL_TO_VALUE
+      operand_value.to_f >= tag_value.to_f
+    else
+      tag_value == operand_value
+    end
+  end
+end

data/lib/vwo/packages/segmentation_evaluator/utils/segment_util.rb

@@ -0,0 +1,44 @@
+# 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 'json'
+
+# Utility function to check if a value is an object (excluding arrays and other types)
+def is_object?(val)
+  val.is_a?(Hash)
+end
+
+# Extracts the first key-value pair from the provided object.
+# @param obj [Hash] The object from which to extract the key-value pair.
+# @return [Hash, nil] A hash containing the first key and value, or nil if input is not a hash.
+def get_key_value(obj)
+  return nil unless is_object?(obj)
+
+  key = obj.keys.first
+  return nil unless key
+
+  { key: key, value: obj[key] }
+end
+
+# Matches a string against a regular expression and returns the match result.
+# @param string [String] The string to match against the regex.
+# @param regex [String] The regex pattern as a string.
+# @return [Array, nil] The results of the regex match, or nil if an error occurs.
+def match_with_regex(string, regex)
+  begin
+    return string.match(Regexp.new(regex))
+  rescue StandardError
+    return nil
+  end
+end

data/lib/vwo/{constants.rb → packages/storage/connector.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,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-module VWO
-    module Constants
-      HTTPS_PROTOCOL = 'https://'
-      BASE_URL = 'dev.visualwebsiteoptimizer.com'
-      ENDPOINT_GET_FLAG = '/server-side/getFlag'
-      ENDPOINT_TRACK_EVENT = '/server-side/trackEvent'
-      ENDPOINT_SET_ATTRIBUTE = '/server-side/setAttribute'
-      ENDPOINT_ACCOUNT_SETTINGS = '/server-side/v2-settings'
+class Connector
+    # Define an abstract method for setting data
+    def set(_key, _data)
+      raise NotImplementedError, "#{self.class} must implement the `set` method"
     end
-  end
+  
+    # Define an abstract method for getting data
+    def get(_key)
+      raise NotImplementedError, "#{self.class} must implement the `get` method"
+    end
+  end
+  

data/lib/vwo/packages/storage/storage.rb

@@ -0,0 +1,45 @@
+# 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 'connector' # Import Connector class
+
+class Storage
+  @instance = nil
+
+  attr_reader :connector
+
+  def initialize
+    @connector = nil
+  end
+
+  # Attach a connector (can be an instance or a class)
+  def attach_connector(connector)
+    if connector.is_a?(Class) # Check if it's a class before instantiating
+      @connector = connector.new
+    else
+      @connector = connector
+    end
+    @connector
+  end
+
+  # Singleton instance method
+  def self.instance
+    @instance ||= new
+  end
+
+  # Get the attached connector
+  def get_connector
+    @connector
+  end
+end

data/lib/vwo/services/campaign_decision_service.rb

@@ -0,0 +1,153 @@
+# 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 '../packages/decision_maker/decision_maker'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../packages/segmentation_evaluator/core/segmentation_manager'
+
+require_relative '../constants/constants'
+require_relative '../models/campaign/variation_model'
+require_relative '../models/campaign/campaign_model'
+require_relative '../models/user/context_model'
+require_relative '../enums/campaign_type_enum'
+require_relative '../utils/data_type_util'
+require_relative '../utils/log_message_util'
+
+class CampaignDecisionService
+  # Determines if a user is part of a campaign based on bucketing logic
+  # @param user_id [String] The ID of the user
+  # @param campaign [CampaignModel] The campaign to check
+  # @return [Boolean] True if the user is part of the campaign, false otherwise
+  def is_user_part_of_campaign(user_id, campaign)
+    return false if campaign.nil? || user_id.nil?
+
+    is_rollout_or_personalize = [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign.get_type)
+    salt = is_rollout_or_personalize ? campaign.get_variations.first.get_salt : campaign.get_salt
+    traffic_allocation = is_rollout_or_personalize ? campaign.get_variations.first.get_weight : campaign.get_traffic
+
+    bucket_key = salt ? "#{salt}_#{user_id}" : "#{campaign.get_id}_#{user_id}"
+    value_assigned_to_user = DecisionMaker.new.get_bucket_value_for_user(bucket_key)
+
+    is_user_part = value_assigned_to_user != 0 && value_assigned_to_user <= traffic_allocation
+
+    LoggerService.log(LogLevelEnum::INFO, "USER_PART_OF_CAMPAIGN", {
+      userId: user_id,
+      notPart: is_user_part ? '' : 'not',
+      campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}"
+    })
+
+    is_user_part
+  end
+
+  # Returns the variation assigned to a user based on bucket value
+  # @param variations [Array<VariationModel>] The variations to check
+  # @param bucket_value [Integer] The bucket value to check
+  # @return [VariationModel] The variation assigned to the user
+  def get_variation(variations, bucket_value)
+    variations.find { |variation| bucket_value >= variation.get_start_range_variation && bucket_value <= variation.get_end_range_variation }
+  end
+
+  # Checks if the bucket value is in the range of the variation
+  # @param variation [VariationModel] The variation to check
+  # @param bucket_value [Integer] The bucket value to check
+  # @return [VariationModel] The variation if the bucket value is in the range, nil otherwise
+  def check_in_range(variation, bucket_value)
+    variation if bucket_value >= variation.get_start_range_variation && bucket_value <= variation.get_end_range_variation
+  end
+
+  # Buckets a user into a variation for a given campaign
+  # @param user_id [String] The ID of the user
+  # @param account_id [String] The ID of the account
+  # @param campaign [CampaignModel] The campaign to bucket the user into
+  # @return [VariationModel] The variation assigned to the user
+  def bucket_user_to_variation(user_id, account_id, campaign)
+    return nil if campaign.nil? || user_id.nil?
+
+    multiplier = campaign.get_traffic ? 1 : nil
+    percent_traffic = campaign.get_traffic
+    salt = campaign.get_salt
+    bucket_key = salt ? "#{salt}_#{account_id}_#{user_id}" : "#{campaign.get_id}_#{account_id}_#{user_id}"
+    
+    hash_value = DecisionMaker.new.generate_hash_value(bucket_key)
+    bucket_value = DecisionMaker.new.generate_bucket_value(hash_value, Constants::MAX_TRAFFIC_VALUE, multiplier)
+
+    LoggerService.log(LogLevelEnum::DEBUG, "USER_BUCKET_TO_VARIATION", {
+      userId: user_id,
+      campaignKey: campaign.get_key,
+      percentTraffic: percent_traffic,
+      bucketValue: bucket_value,
+      hashValue: hash_value
+    })
+
+    get_variation(campaign.get_variations, bucket_value)
+  end
+
+  # Pre-segmentation decision based on user context and campaign rules
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  # @return [Boolean] True if the user satisfies the campaign rules, false otherwise
+  def get_pre_segmentation_decision(campaign, context)
+    campaign_type = campaign.get_type
+    segments = if [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign_type)
+                 campaign.get_variations.first.get_segments
+               elsif campaign_type == CampaignTypeEnum::AB
+                 campaign.get_segments
+               end
+
+    if DataTypeUtil.is_object(segments) && segments.empty?
+      LoggerService.log(LogLevelEnum::INFO, "SEGMENTATION_SKIP", {
+        userId: context.get_id,
+        campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}"
+      })
+      return true
+    else
+      pre_segmentation_result = SegmentationManager.instance.validate_segmentation(segments, context.get_custom_variables)
+
+      if !pre_segmentation_result
+        LoggerService.log(LogLevelEnum::INFO, "SEGMENTATION_STATUS", {
+          userId: context.get_id,
+          campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+          status: 'failed'
+        })
+        return false
+      end
+
+      LoggerService.log(LogLevelEnum::INFO, "SEGMENTATION_STATUS", {
+        userId: context.get_id,
+        campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+        status: 'passed'
+      })
+
+      return true
+    end
+  end
+
+  # Determines the variation assigned to a user for a campaign
+  # @param user_id [String] The ID of the user
+  # @param account_id [String] The ID of the account
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @return [VariationModel] The variation assigned to the user
+  def get_variation_alloted(user_id, account_id, campaign)
+    is_user_part = is_user_part_of_campaign(user_id, campaign)
+
+    if [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign.get_type)
+      return campaign.get_variations.first if is_user_part
+    else
+      return bucket_user_to_variation(user_id, account_id, campaign) if is_user_part
+    end
+
+    nil
+  end
+end

data/lib/vwo/services/hooks_service.rb

@@ -0,0 +1,51 @@
+# 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/vwo_options_model'
+require_relative '../utils/data_type_util'
+
+class HooksService
+  attr_reader :decision
+
+  def initialize(options)
+    @callback = options.dig(:integrations, :callback)
+    @is_callback_function = is_function?(@callback)
+    @decision = {}
+  end
+
+  # Executes the callback
+  # @param properties [Hash] Properties from the callback
+  def execute(properties)
+    @callback.call(properties) if @is_callback_function
+  end
+
+  # Sets properties to the decision object
+  # @param properties [Hash] Properties to set
+  def set(properties)
+    @decision = properties if @is_callback_function
+  end
+
+  # Retrieves the decision object
+  # @return [Hash] The decision object
+  def get
+    @decision
+  end
+
+  private
+
+  # Helper function to check if a value is a function (assumed from data_type_util.rb)
+  def is_function?(val)
+    val.respond_to?(:call)
+  end
+end

data/lib/vwo/services/logger_service.rb

@@ -0,0 +1,83 @@
+# 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 'json'
+require_relative '../vwo_client'
+require_relative '../packages/logger/core/log_manager'
+require_relative '../enums/log_level_enum'
+require_relative '../utils/log_message_util'
+
+class LoggerService
+  class << self
+    attr_accessor :debug_messages, :info_messages, :error_messages, :warning_messages
+  end
+
+  def self.log(level, key = nil, map = {})
+    log_manager = LogManager.instance
+
+    if key && map
+      message = build_message(get_messages(level)[key], map)
+    else
+      message = key # key acts as the message when no map is provided
+    end
+
+    case level
+    when LogLevelEnum::DEBUG
+      log_manager.debug(message)
+    when LogLevelEnum::INFO
+      log_manager.info(message)
+    when LogLevelEnum::WARN
+      log_manager.warn(message)
+    else
+      log_manager.error(message)
+    end
+  end
+
+  def initialize(config = {})
+    # Initialize the LogManager
+    LogManager.instance(config)
+
+    # Read the log files and set class variables
+    self.class.debug_messages = read_log_files('debug_messages.json')
+    self.class.info_messages = read_log_files('info_messages.json')
+    self.class.error_messages = read_log_files('error_messages.json')
+    self.class.warning_messages = read_log_files('warn_messages.json')
+  end
+
+  private
+
+  def read_log_files(file_name)
+    begin
+      # Use absolute path resolution from the project root
+      file_path = File.join(File.expand_path('../../resources', __dir__), file_name)
+      return JSON.parse(File.read(file_path))
+    rescue StandardError => e
+      puts "Error reading log file #{file_name}: #{e.message}"
+      return {}
+    end
+  end
+
+  def self.get_messages(level)
+    case level
+    when LogLevelEnum::DEBUG
+      @debug_messages
+    when LogLevelEnum::INFO
+      @info_messages
+    when LogLevelEnum::WARN
+      @warning_messages
+    else
+      @error_messages
+    end
+  end
+end