ibm_appconfiguration_ruby_sdk 0.1.0.pre.rc.0

data/lib/ibm_appconfiguration_ruby_sdk/configurations/internal/retry_manager/config_fetcher.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+# Copyright 2026 IBM Corp. All Rights Reserved.
+#
+# 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 "../../../core/api_manager"
+require_relative "../../../core/url_builder"
+require_relative "../utils"
+require_relative "../logger"
+require_relative "../../models/feature"
+require_relative "../../models/property"
+require_relative "../../models/segment"
+require_relative "../../configuration_handler"
+
+# ConfigFetcher
+#
+# Handles fetching configurations from the App Configuration API.
+# This class encapsulates all API call logic and response handling.
+#
+class ConfigFetcher
+  # Initialize the config fetcher
+  #
+  # @param collection_id [String] Collection ID for API request
+  # @param environment_id [String] Environment ID for API request
+  # @param logger [Logger] Optional logger instance
+  def initialize(collection_id:, environment_id:, logger: nil)
+    @collection_id = collection_id
+    @environment_id = environment_id
+    @logger = logger || Logger.instance
+  end
+
+  # Fetch configuration from API
+  #
+  # Makes a direct API call to the /config endpoint
+  # Returns a hash with status information
+  #
+  # @return [Hash] Result hash with :ok, :retryable, :status, and :data keys
+  def fetch
+    # Get the BaseService client
+    client = ApiManager.base_service_client
+    url_builder = UrlBuilder.instance
+
+    # Build the API endpoint URL
+    api_path = "/apprapp/feature/v1/instances/#{url_builder.guid}/config"
+
+    @logger.info("📡 Calling API: #{url_builder.base_service_url}#{api_path}")
+
+    # Make the API request
+    response = client.request(
+      method: "GET",
+      url: api_path,
+      headers: ApiManager.headers,
+      params: {
+        action: "sdkConfig",
+        collection_id: @collection_id,
+        environment_id: @environment_id
+      }
+    )
+
+    # Success case
+    if response.status == 200
+      @logger.info("✓ API call successful (200)")
+      {
+        ok: true,
+        retryable: false,
+        status: 200,
+        data: response.result
+      }
+    else
+      # Unexpected status code
+      @logger.warn("⚠️  Unexpected status code: #{response.status}")
+      {
+        ok: false,
+        retryable: true,
+        status: response.status,
+        data: nil
+      }
+    end
+  rescue IBMCloudSdkCore::ApiException => e
+    status_code = e.code.to_i
+    @logger.error("❌ API Exception: #{e.message} (Status: #{status_code})")
+
+    # Determine if error is retryable
+    # Non-retryable: 4xx except 429
+    # Retryable: 429, 5xx
+    retryable = status_code == 429 || status_code >= 500
+
+    {
+      ok: false,
+      retryable: retryable,
+      status: status_code,
+      data: nil
+    }
+  rescue StandardError => e
+    @logger.error("❌ Unexpected error: #{e.message}")
+    @logger.error(e.backtrace.first(3).join("\n"))
+
+    # Treat unexpected errors as retryable
+    {
+      ok: false,
+      retryable: true,
+      status: 500,
+      data: nil
+    }
+  end
+
+  # Display API response in a readable format
+  #
+  # @param data [Hash] API response data
+  def display_response(data)
+    # require 'json'
+
+    # @logger.info("\n📊 API Response Summary:")
+    # @logger.info("-" * 80)
+
+    # # Display features
+    # if data['features'] && data['features'].any?
+    #   @logger.info("\n📋 Features (#{data['features'].length}):")
+    #   data['features'].each_with_index do |feature, index|
+    #     @logger.info("  #{index + 1}. #{feature['name']} (#{feature['feature_id']})")
+    #     @logger.info("     Type: #{feature['type']}")
+    #     @logger.info("     Enabled: #{feature['enabled']}")
+    #     if feature['segment_rules'] && feature['segment_rules'].any?
+    #       @logger.info("     Segment Rules: #{feature['segment_rules'].length}")
+    #     end
+    #   end
+    # else
+    #   @logger.info("\n📋 Features: None")
+    # end
+
+    # # Display properties
+    # if data['properties'] && data['properties'].any?
+    #   @logger.info("\n🔧 Properties (#{data['properties'].length}):")
+    #   data['properties'].each_with_index do |property, index|
+    #     @logger.info("  #{index + 1}. #{property['name']} (#{property['property_id']})")
+    #     @logger.info("     Type: #{property['type']}")
+    #     @logger.info("     Value: #{property['value']}")
+    #     if property['segment_rules'] && property['segment_rules'].any?
+    #       @logger.info("     Segment Rules: #{property['segment_rules'].length}")
+    #     end
+    #   end
+    # else
+    #   @logger.info("\n🔧 Properties: None")
+    # end
+
+    # # Display segments
+    # if data['segments'] && data['segments'].any?
+    #   @logger.info("\n👥 Segments (#{data['segments'].length}):")
+    #   data['segments'].each_with_index do |segment, index|
+    #     @logger.info("  #{index + 1}. #{segment['name']} (#{segment['segment_id']})")
+    #     if segment['rules'] && segment['rules'].any?
+    #       @logger.info("     Rules: #{segment['rules'].length}")
+    #     end
+    #   end
+    # else
+    #   @logger.info("\n👥 Segments: None")
+    # end
+
+    # @logger.info("\n📄 Full JSON Response:")
+    # @logger.info("-" * 80)
+    # @logger.info(JSON.pretty_generate(data))
+    # @logger.info("=" * 80)
+  end
+
+  # Process API response and load to cache
+  #
+  # This method:
+  # 1. Takes the raw API response
+  # 2. Calls extract_configurations to parse and validate the data
+  # 3. Calls load_configurations_to_cache to store in cache
+  #
+  # @param api_response [Hash] Raw API response data
+  # @return [Boolean] true if processing was successful, false otherwise
+  def process_and_load_configurations(api_response)
+    return false unless api_response
+
+    begin
+      @logger.info("🔄 Processing API response...")
+
+      # Convert string keys to symbol keys if needed
+      symbolized_data = symbolize_keys(api_response)
+
+      # Extract configurations using utils.rb method
+      # This validates the data and extracts only the relevant features, properties, and segments
+      # for the specified environment and collection
+      extracted_config = extract_configurations(
+        symbolized_data,
+        @environment_id,
+        @collection_id
+      )
+
+      @logger.info("✓ Configurations extracted successfully")
+      @logger.info("  Features: #{extracted_config[:features]&.length || 0}")
+      @logger.info("  Properties: #{extracted_config[:properties]&.length || 0}")
+      @logger.info("  Segments: #{extracted_config[:segments]&.length || 0}")
+
+      # Load the extracted configurations to cache
+      success = load_configurations_to_cache(extracted_config)
+
+      if success
+        @logger.info("✅ Configurations processed and loaded successfully")
+      else
+        @logger.error("❌ Failed to load configurations to cache")
+      end
+
+      success
+    rescue StandardError => e
+      @logger.error("❌ Error processing API response: #{e.message}")
+      @logger.error(e.backtrace.first(5).join("\n"))
+      false
+    end
+  end
+
+  # Load configurations to cache
+  #
+  # Delegates to ConfigurationHandler singleton to maintain a single source of truth.
+  # This ensures all parts of the application use the same cache.
+  #
+  # @param data [Hash] Configuration data with :features, :properties, and :segments keys
+  # @return [Boolean] true if configurations were loaded successfully
+  def load_configurations_to_cache(data)
+    return false unless data
+
+    begin
+      @logger.info("📦 Loading configurations to ConfigurationHandler cache...")
+
+      # Delegate to ConfigurationHandler singleton (single source of truth)
+      handler = ConfigurationHandler.instance
+      handler.load_configurations_to_cache(data)
+
+      @logger.info("✅ Configurations loaded to cache successfully")
+      @logger.info("  ✓ Features: #{data[:features]&.length || 0}")
+      @logger.info("  ✓ Properties: #{data[:properties]&.length || 0}")
+      @logger.info("  ✓ Segments: #{data[:segments]&.length || 0}")
+
+      true
+    rescue StandardError => e
+      @logger.error("❌ Error loading configurations to cache: #{e.message}")
+      @logger.error(e.backtrace.first(5).join("\n"))
+      false
+    end
+  end
+end

data/lib/ibm_appconfiguration_ruby_sdk/configurations/internal/utils.rb

@@ -0,0 +1,240 @@
+# Copyright 2026 IBM Corp. All Rights Reserved.
+#
+# 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.
+
+# frozen_string_literal: true
+
+require "murmurhash3"
+
+# Validates feature/property belongs to collection if it contains collections else gives true as default
+# @param resource [Hash] The resource (feature or property)
+# @param collection [String] The collection ID
+# @return [Boolean]
+def validate_resource(resource, collection)
+  # If collections is not present the resource data is coming from SDK APIs
+  return true unless resource.key?(:collections)
+
+  collections = resource[:collections]
+  raise "Improper collection format in resource data" unless collections.is_a?(Array)
+
+  collections.any? { |coll| coll[:collection_id] == collection }
+end
+
+# Appends segment ids to the provided set
+# @param resource [Hash] The resource (feature or property)
+# @param segment_ids [Set] Set to store segment IDs
+def append_segment_id(resource, segment_ids)
+  return unless resource[:segment_rules]
+
+  resource[:segment_rules].each do |segment_rule|
+    segment_rule[:rules].each do |rule|
+      rule[:segments].each do |segment_id|
+        segment_ids.add(segment_id)
+      end
+    end
+  end
+end
+
+# Prepares config data for extraction with validation
+# @param data [Hash] Configuration data
+# @param environment_id [String] Environment ID
+# @return [Hash] Hash containing features, properties, and segments
+def extract_environment_data(data, environment_id)
+  unless data.key?(:segments) && data[:segments].is_a?(Array) &&
+         data.key?(:environments) && data[:environments].is_a?(Array)
+    raise "Improper Data format present in configuration"
+  end
+
+  data[:environments].each do |environment|
+    next unless environment[:environment_id] == environment_id
+
+    result = {
+      features: environment[:features] || [],
+      properties: environment[:properties] || [],
+      segments: data[:segments]
+    }
+    puts "🔍 extract_environment_data: Found environment '#{environment_id}'"
+    puts "   Features: #{result[:features].length}"
+    puts "   Properties: #{result[:properties].length}"
+    puts "   Segments: #{result[:segments].length}"
+    return result
+  end
+
+  raise "Matching environment not found in configuration"
+end
+
+# Returns object containing features, properties, segments after validation
+# @param resource_data [Hash] Resource data containing features, properties, and segments
+# @param collection [String] Collection ID
+# @return [Hash] Hash containing validated features, properties, and segments
+def extract_resources(resource_data, collection)
+  features = []
+  properties = []
+  segments = []
+  segment_ids = Set.new
+
+  puts "🔍 DEBUG extract_resources:"
+  puts "  Features in resource_data: #{resource_data[:features]&.length || 0}"
+  puts "  Properties in resource_data: #{resource_data[:properties]&.length || 0}"
+  puts "  Collection to match: #{collection}"
+
+  # Appending features with validation to features array
+  resource_data[:features].each do |feature|
+    valid = validate_resource(feature, collection)
+    if valid
+      append_segment_id(feature, segment_ids)
+      features << feature
+    end
+  end
+
+  # Appending properties with validation to properties array
+  resource_data[:properties].each do |property|
+    valid = validate_resource(property, collection)
+    if valid
+      append_segment_id(property, segment_ids)
+      properties << property
+    end
+  end
+
+  # Appending only required segments to segments array and throw error if any required segment is absent
+  resource_data[:segments].each do |segment|
+    if segment_ids.include?(segment[:segment_id])
+      segments << segment
+      segment_ids.delete(segment[:segment_id])
+    end
+  end
+
+  raise "Required segment doesn't exist in provided segments" if segment_ids.size.positive?
+
+  {
+    features: features,
+    properties: properties,
+    segments: segments
+  }
+end
+
+# Unified parser for app-config data for new sdk-config format, export and promote data format
+# @param configurations [Hash] Configuration JSON data (with symbol keys)
+# @param environment [String] Environment ID
+# @param collection [String] Collection ID
+# @return [Hash] Hash containing features, properties, and segments
+def extract_configurations(configurations, environment, collection)
+  puts "🔍 extract_configurations called"
+  puts "   Environment: #{environment}"
+  puts "   Collection: #{collection}"
+
+  # Check if data belongs to correct collection
+  raise "Improper/Missing collections in configuration" unless configurations.key?(:collections) && configurations[:collections].is_a?(Array)
+
+  match_found = false
+  configurations[:collections].each do |coll|
+    puts "   Checking collection: #{coll[:collection_id]}"
+    if coll[:collection_id] == collection
+      match_found = true
+      break
+    end
+  end
+
+  raise "Required collection not found in collections" unless match_found
+
+  puts "   Collection match found!"
+
+  # Data in SDK config/export/promote format
+  config_data = extract_environment_data(configurations, environment)
+  puts "   After extract_environment_data: features=#{config_data[:features]&.length}"
+
+  result = extract_resources(config_data, collection)
+  puts "   After extract_resources: features=#{result[:features]&.length}"
+
+  result
+rescue StandardError => e
+  puts "❌ ERROR in extract_configurations: #{e.message}"
+  puts e.backtrace.first(5).join("\n")
+  raise "Extraction of configurations failed with error:\n #{e.message}"
+end
+
+# Helper method to convert string keys to symbol keys recursively
+# @param obj [Object] The object to convert
+# @return [Object] The converted object with symbol keys
+def symbolize_keys(obj)
+  case obj
+  when Hash
+    obj.each_with_object({}) do |(key, value), result|
+      result[key.to_sym] = symbolize_keys(value)
+    end
+  when Array
+    obj.map { |item| symbolize_keys(item) }
+  else
+    obj
+  end
+end
+
+##
+# Compute hash using MurmurHash3
+# @param str [String] String to hash
+# @return [Integer] Hash value
+def compute_hash(str)
+  seed = 0
+  MurmurHash3::V32.str_hash(str, seed)
+end
+
+##
+# Get normalized value for rollout percentage calculation
+# @param str [String] String to normalize
+# @return [Integer] Normalized value (0-100)
+def get_normalized_value(str)
+  max_hash_value = 2**32
+  normalizer = 100
+  ((compute_hash(str).to_f / max_hash_value) * normalizer).floor
+end
+
+##
+# Parse progressive rollout phases into a sorted hash for timestamp-to-percentage lookups.
+# @param configuration [Hash] Rollout config with start_at and phases
+# @return [Hash] Sorted hash mapping timestamp (ms) -> percentage
+# @raise [ArgumentError] If configuration is invalid
+def parse_rollout_configuration_phases(configuration)
+  # Validate input
+  raise ArgumentError.new("Invalid rollout configuration") unless configuration&.key?(:start_at) && configuration[:phases].is_a?(Array)
+
+  # Time unit multipliers (to milliseconds)
+  multipliers = {
+    "days" => 86_400_000,
+    "hours" => 3_600_000,
+    "minutes" => 60_000
+  }
+
+  # Parse start timestamp
+  begin
+    start_timestamp = Time.parse(configuration[:start_at]).to_i * 1000 # Convert to milliseconds
+  rescue ArgumentError
+    raise ArgumentError.new("Invalid start_at: #{configuration[:start_at]}")
+  end
+
+  # Initialize result hash with initial entry
+  result = { 0 => 0 }
+  transition_time = start_timestamp
+
+  # Process each phase
+  configuration[:phases].each do |phase|
+    next unless phase.is_a?(Hash) && phase.key?(:percentage) && phase[:percentage].is_a?(Numeric)
+
+    result[transition_time] = phase[:percentage]
+
+    # Calculate next transition time if duration is specified
+    transition_time += multipliers[phase[:duration_type]] * phase[:duration] if phase[:duration] && phase[:duration_type] && multipliers[phase[:duration_type]]
+  end
+
+  # Return sorted hash (Ruby hashes maintain insertion order, so we sort by key)
+  result.sort.to_h
+end