oci-logging-analytics-kubernetes-discovery 1.0.3 → 1.1.0

data/lib/util/service_logs.rb

@@ -0,0 +1,559 @@
+## Copyright (c) 2024 Oracle and/or its affiliates.
+## The Universal Permissive License (UPL), Version 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+require_relative '../enum/stack_job_operation_enum'
+require_relative '../enum/stack_job_lifecycle_state_enum'
+require_relative '../enum/infrastructure_resource_discovery'
+
+require_relative 'string_utils'
+require_relative '../discover/infrastructure'
+
+module Util
+  module ServiceLogs
+    extend Util::Logging
+    extend Discover::Infrastructure
+    extend Util::StringUtils
+
+    module_function
+
+    DELETION_RETRY_ATTEMPTS = 5
+
+    # Prefix of resource manager stack (to be created via API)
+    RESOURCE_MANAGER_STACK_PREFIX = 'oci-kubernetes-monitoring-service-logs'.freeze
+
+    def invoke_resource_manager_stack(infra_objects_payload, app_config_hash,
+          oci_la_log_group_id, onm_compartment_id, oci_region, oci_domain)
+
+      rms_template_base64_encoded = app_config_hash[:rms_template_base64_encoded]
+      stack_operation_timeout = app_config_hash[:stack_operation_timeout].to_i
+      cluster_details = infra_objects_payload.to_hash[:cluster]
+      subnet_details = infra_objects_payload.to_hash[:subnets]
+      load_balancer_details = infra_objects_payload.to_hash[:loadbalancers]
+
+      existing_stack = nil
+      check_for_existing_service_discovery_stack = false
+
+      # Fetch stack ID from configmap
+      cfgmap_stack_id_entry = Util::StateManager.state.svc_log_stack_id
+
+      if cfgmap_stack_id_entry.nil? || cfgmap_stack_id_entry.empty?
+        # If there is no entry in config map, use fallback method to check if stack exists
+        check_for_existing_service_discovery_stack = true
+      else
+        # If there is entry in config map, double check if the stack exists
+        begin
+          existing_stack = fetch_stack_details(cfgmap_stack_id_entry)
+        rescue StandardError => e
+          logger.error("Unable to fetch stack details to confirm if it exists. Stack OCID: [#{cfgmap_stack_id_entry}], Error: [#{e}]")
+          check_for_existing_service_discovery_stack = true
+        end
+      end
+
+      if check_for_existing_service_discovery_stack
+        # Prepare stack name using cluster OCID
+        logger.debug('Preparing stack name using cluster OCID')
+        stack_unique_identifier = prepare_stack_unique_identifier(cluster_details[:ocid])
+
+        # Check if the stack already exists
+        logger.info("Checking if stack name [#{stack_unique_identifier}] already exists")
+        available_stack_list = fetch_stack_list(onm_compartment_id)
+        available_stack_list.each do |item|
+          if item.display_name == stack_unique_identifier
+            existing_stack = item
+            break
+          end
+        end
+      end
+
+      # Prepare map object (in the form expected by stack)
+      subnet_map = prepare_map_using_resource_list(subnet_details) unless subnet_details.nil?
+      load_balancer_map = prepare_map_using_resource_list(load_balancer_details) unless load_balancer_details.nil?
+      cluster_map = prepare_map_using_resource_list(Array.new(1) { cluster_details }) unless cluster_details.nil?
+
+      # Set variables
+      rms_input_variables = {}
+      oci_tags_json = app_config_hash[:oci_tags_json]
+      oci_tags_str = app_config_hash[:oci_tags_str]
+
+      rms_input_variables['load_balancers'] = load_balancer_map.nil? ? '{}' : load_balancer_map.to_json
+      rms_input_variables['subnets'] = subnet_map.nil? ? '{}' : subnet_map.to_json
+      rms_input_variables['cluster'] = cluster_map.nil? ? '{}' : cluster_map.to_json
+      rms_input_variables['oci_region'] = oci_region
+      rms_input_variables['log_analytics_log_group'] = oci_la_log_group_id
+      rms_input_variables['onm_compartment_id'] = onm_compartment_id
+      rms_input_variables['oci_domain'] = oci_domain unless oci_domain.nil?
+      rms_input_variables['tags'] = oci_tags_str
+
+      if existing_stack.nil?
+        logger.info('Stack does not exists. Creating...')
+        stack_details = create_stack_using_zip_upload(onm_compartment_id,
+                                      stack_unique_identifier,
+                                      rms_template_base64_encoded.chomp,
+                                      rms_input_variables, oci_tags_json)
+        logger.info("Successfully created the stack. Stack ID: [#{stack_details.id}]")
+
+        # Create an entry of stack ID in the configmap
+        Util::StateManager.state.svc_log_stack_id = stack_details.id
+        Util::StateManager.update_state_configmap
+
+        # Run apply job
+        logger.info('Initiating apply job.')
+        job_detail = create_apply_job(stack_details.id, oci_tags_json)
+
+        # Wait for job status check till timeout
+        job_status_check(job_detail.id, stack_operation_timeout)
+      else
+        logger.info("Existing stack found. Stack ID: [#{existing_stack.id}]")
+
+        if check_for_existing_service_discovery_stack
+          # Create an entry of stack ID in the configmap
+          Util::StateManager.state.svc_log_stack_id = existing_stack.id
+          Util::StateManager.update_state_configmap
+        end
+
+        # Fetch stack details to compare the existing list of resources with the new ones
+        logger.info("Fetching variables. Stack ID: [#{existing_stack.id}]")
+
+        stack_details = fetch_stack_details(existing_stack.id)
+        existing_load_balancer_details = JSON.parse(stack_details.variables['load_balancers'])
+        existing_subnets_details = JSON.parse(stack_details.variables['subnets'])
+
+        # Check if an update to resource list is required
+        load_balancer_diffs = calculate_deltas(existing_load_balancer_details, load_balancer_map)
+        subnet_diffs = calculate_deltas(existing_subnets_details, subnet_map)
+
+        load_balancer_diffs[:deletions] = verify_deleted_resources(load_balancer_diffs[:deletions], Enum::InfrastructureResourceDiscovery::LOAD_BALANCER)
+        subnet_diffs[:deletions] = verify_deleted_resources(subnet_diffs[:deletions], Enum::InfrastructureResourceDiscovery::SUBNET)
+
+        # Cleanup retry eligible resource map in config map. The resources which were assumed to be deleted in previous
+        # runs might not have been actually deleted but their retry references might still be there in config map
+        retry_eligible_resource_map = parse_key_value_pairs(Util::StateManager.state.retry_eligible_resources)
+
+        load_balancer_map.each do |key, value|
+          retry_eligible_resource_map.delete(key)
+        end
+
+        subnet_map.each do |key, value|
+          retry_eligible_resource_map.delete(key)
+        end
+
+        retry_eligible_resource_map_str = to_key_value_string(retry_eligible_resource_map)
+        Util::StateManager.state.retry_eligible_resources = retry_eligible_resource_map_str
+        Util::StateManager.update_state_configmap
+
+        skip_apply_job = false
+
+        if subnet_diffs[:deletions].length.positive? || load_balancer_diffs[:deletions].length.positive?
+          # Scenario 1: Resources were deleted. Even if new resources are discovered,
+          # retries for deleted resources should be exhausted before updating the
+          # resource list and proceeding with stack operations.
+          logger.info('Resource deletion detected. Performing a double-check to confirm the deletion status.')
+
+          lb_deletion_status_check = deletion_retries_exhausted?(load_balancer_diffs[:deletions])
+          subnet_deletion_status_check = deletion_retries_exhausted?(subnet_diffs[:deletions])
+
+          if lb_deletion_status_check && subnet_deletion_status_check
+            logger.info('Resource(s) confirmed as deleted. Proceeding to delete associated logs.')
+            rms_input_variables['load_balancers'] = update_resource_list(existing_load_balancer_details, load_balancer_diffs).to_json
+            rms_input_variables['subnets'] = update_resource_list(existing_subnets_details, subnet_diffs).to_json
+
+            # Clear the retry eligible resource list in config map
+            retry_eligible_resource_map = {}
+            retry_eligible_resource_map_str = to_key_value_string(retry_eligible_resource_map)
+            logger.info('Stack updated with deleted resources')
+            logger.debug("Updating 'retry_eligible_resources' in Config Map [#{retry_eligible_resource_map_str}]")
+
+            Util::StateManager.state.retry_eligible_resources = retry_eligible_resource_map_str
+            Util::StateManager.update_state_configmap
+            skip_apply_job = false
+          else
+            logger.info('Resource log deletion skipped due to required wait time; skipping stack apply.')
+            skip_apply_job = true
+          end
+        elsif subnet_diffs[:additions].length.positive? || load_balancer_diffs[:additions].length.positive?
+          # Scenario 2: Only additions occurred. Update resource list and proceed with stack APPLY.
+          logger.info('New resources have been discovered; Updating resource list.')
+          rms_input_variables['load_balancers'] = update_resource_list(existing_load_balancer_details, load_balancer_diffs).to_json
+          rms_input_variables['subnets'] = update_resource_list(existing_subnets_details, subnet_diffs).to_json
+          skip_apply_job = false
+        else
+          # Scenario 3: No new resources discovered.
+          logger.info('No new resources have been discovered.')
+          # Fetch stack job list and validate the job status of the latest job run
+          logger.info('Checking the status of last 3 stack operations.')
+          job_list = list_jobs(existing_stack.id)
+
+          failed_apply_job_limit = 3
+          failed_job_count = 0
+
+          # Will iterate through the job list; we have last 3 stack operation records
+          job_list.each_with_index do |job, index|
+            if index == 0
+              # If the most recent job is success
+              if job.operation == Enum::StackJobOperationEnum::APPLY and job.lifecycle_state == Enum::StackJobLifecycleStateEnum::SUCCEEDED
+                logger.info("Latest Job operation: #{job.operation} is successful. Stack apply operation skipped.")
+                skip_apply_job = true
+                break
+              end
+
+              # If the most recent job is still running
+              if [Enum::StackJobLifecycleStateEnum::IN_PROGRESS, Enum::StackJobLifecycleStateEnum::ACCEPTED].include?(job.lifecycle_state)
+                logger.info('The latest job is in progress or accepted state. Stack apply operation skipped.')
+                skip_apply_job = true
+                break
+              end
+            end
+
+            logger.info("Job #{index}: #{job.operation} - #{job.lifecycle_state} - #{job.time_created}")
+
+            if job.lifecycle_state == Enum::StackJobLifecycleStateEnum::FAILED && job.operation == Enum::StackJobOperationEnum::APPLY
+              failed_job_count += 1
+              logger.info("Failed Apply Job Count: #{failed_job_count}")
+            end
+
+            if failed_job_count >= failed_apply_job_limit
+              logger.error('Multiple sequential FAILED Stack APPLY operations detected. Stack apply operation skipped.')
+              skip_apply_job = true
+              break
+            end
+
+            if index == 2
+              break # We only track latest 3 jobs
+            end
+          end
+        end
+
+        unless skip_apply_job
+          logger.info('Updating stack terraform and input variables.')
+          update_stack(existing_stack.id, rms_input_variables, rms_template_base64_encoded)
+
+          logger.info('Proceeding with stack apply operation.')
+          logger.info("Stack variables updated. Stack ID: [#{existing_stack.id}]")
+          # Run apply job
+          logger.info('Initiating apply job.')
+          job_detail = create_apply_job(existing_stack.id, oci_tags_json)
+          # Wait for job status check till timeout
+          job_status_check(job_detail.id, stack_operation_timeout)
+        end
+      end
+    end
+
+    def prepare_map_using_resource_list(resource_list)
+      resource_map = {}
+      resource_list.each do |item|
+        # OCID is set a key
+        resource_map[item[:ocid]] = { name: item[:name], ocid: item[:ocid], compartment_id: item[:compartmentId] }
+      end
+      resource_map
+    end
+
+    def update_resource_list(existing_resource_list, resource_list_diff)
+      # Loop through additions and add to existing list
+      resource_list_diff[:additions].each do |key, value|
+        existing_resource_list[key] = value
+      end
+
+      # Loop through deletions and remove from existing list
+      resource_list_diff[:deletions].each do |key, value|
+        existing_resource_list.delete(key)
+      end
+
+      return existing_resource_list
+    end
+
+    def calculate_deltas(previous_resource_list, current_resource_list)
+      resource_additions = {}
+      resource_deletions = {}
+
+      # Loop through current list and check if it has new resource as compared to previous list
+      current_resource_list.each do |key, value|
+        if previous_resource_list[key].nil?
+          resource_additions[key] = value
+        end
+      end
+
+      # Loop through previous list and check if it does not have resource in the current list
+      previous_resource_list.each do |key, value|
+        if current_resource_list[key].nil?
+          resource_deletions[key] = value
+        end
+      end
+
+      { additions: resource_additions, deletions: resource_deletions }
+    end
+
+    def verify_deleted_resources(deleted_resource_list, resource_type)
+      false_positive_resources = []
+
+      # Check resource status
+      deleted_resource_list.each do |key, value|
+        resource_details = nil
+
+        case resource_type
+        when Enum::InfrastructureResourceDiscovery::SUBNET
+          resource_details = Discover::Infrastructure.fetch_subnet_details(key)
+        when Enum::InfrastructureResourceDiscovery::LOAD_BALANCER
+          resource_details = Discover::Infrastructure.fetch_load_balancer_details(key)
+        end
+
+        # Resources with 200 are not actually deleted.
+        if resource_details[:status] == 200
+          logger.trace("#{resource_details[:status]} encountered for [#{key}]. Resource actually not deleted.")
+          false_positive_resources.push(key)
+
+          # Remove the resource from config map if it exists
+          retry_eligible_resource_map = parse_key_value_pairs(Util::StateManager.state.retry_eligible_resources)
+          retry_eligible_resource_map.delete(key)
+          retry_eligible_resource_map_str = to_key_value_string(retry_eligible_resource_map)
+          Util::StateManager.state.retry_eligible_resources = retry_eligible_resource_map_str
+          Util::StateManager.update_state_configmap
+
+          next
+        end
+
+        # Wait only for 404 and give it retries. Handle 401 same as 401
+        if resource_details[:status] == 404 || resource_details[:status] == 401
+          logger.trace("#{resource_details[:status]} encountered for [#{key}]. Verified deletion.")
+          next
+        end
+
+        # For 429 and 5xx we don't know the correct state of resource.
+        # Don't count these statuses in retries and skip the STACK apply.
+        if resource_details[:status] == 429 || resource_details[:status] >= 500
+          logger.error("#{resource_details[:status]} encountered for [#{key}]. Skipping Stack APPLY; Unable to verify correct resource state.")
+          raise StandardError, 'Skipping Stack APPLY; Unable to verify correct resource state.'
+        end
+      end
+
+      false_positive_resources.each do |false_positive_resource|
+        deleted_resource_list.delete(false_positive_resource)
+      end
+
+      deleted_resource_list
+    end
+
+    def deletion_retries_exhausted?(resource_list)
+      # Check the number of retries remaining for retry eligible resources. Fetch data from config map
+      return true if resource_list.empty?
+
+      can_delete = true
+      retry_eligible_resource_map = parse_key_value_pairs(Util::StateManager.state.retry_eligible_resources)
+
+      resource_list.each do |key, value|
+        if retry_eligible_resource_map.has_key?(key)
+          retry_remaining = retry_eligible_resource_map[key]
+          retry_remaining -= 1
+          if retry_remaining.positive?
+            logger.info("#{retry_remaining} deletion retry attempts remaining for [#{key}]")
+            can_delete = false
+          else
+            logger.info("[#{key}] deletion retry attempts exhausted. Marked for deletion.")
+          end
+          retry_eligible_resource_map[key] = retry_remaining
+        else
+          logger.info("First occurrence of [#{key}] as retry eligible resource, #{DELETION_RETRY_ATTEMPTS} attempts remaining")
+          retry_eligible_resource_map[key] = DELETION_RETRY_ATTEMPTS
+          can_delete = false
+        end
+      end
+
+      can_delete = retry_eligible_resource_map.values.all? { |value| value <= 0 }
+
+      # Write back to config map
+      retry_eligible_resource_map_str = to_key_value_string(retry_eligible_resource_map)
+      logger.debug("Updating 'retry_eligible_resources' in Config Map [#{retry_eligible_resource_map_str}]")
+
+      Util::StateManager.state.retry_eligible_resources = retry_eligible_resource_map_str
+      Util::StateManager.update_state_configmap
+
+      can_delete
+    end
+
+    def prepare_stack_unique_identifier(cluster_ocid)
+      substring_length = -11
+      # Pick the last characters of cluster OCID indicated by 'substring_length'
+      truncated_cluster_ocid = cluster_ocid[substring_length..-1]
+      format('%<stack_prefix>s-%<cluster_ocid>s', stack_prefix: RESOURCE_MANAGER_STACK_PREFIX,
+                                                  cluster_ocid: truncated_cluster_ocid)
+    end
+
+    def fetch_stack_list(compartment_id)
+      opts = { compartment_id: compartment_id }
+      begin
+        client = Util::OCIClients.get_clients[:rms_client]
+        response = client.list_stacks(opts)
+        response.data
+      rescue StandardError => e
+        logger.error("Error while fetching list of stacks: #{e}")
+        raise StandardError, 'Error while fetching list of stacks.'
+      end
+    end
+
+    def create_stack_using_zip_upload(compartment_id, stack_unique_identifier, rms_template_base64_encoded,
+                                      rms_input_variables, oci_tags)
+      begin
+        client = Util::OCIClients.get_clients[:rms_client]
+        response =
+          client.create_stack(
+            OCI::ResourceManager::Models::CreateStackDetails.new(
+              compartment_id: compartment_id,
+              terraform_version: '1.2.x',
+              display_name: stack_unique_identifier,
+              description: stack_unique_identifier,
+              config_source:
+                OCI::ResourceManager::Models::CreateZipUploadConfigSourceDetails
+                  .new(
+                    zip_file_base64_encoded: rms_template_base64_encoded
+                  ),
+              variables: rms_input_variables,
+              freeform_tags: oci_tags['freeformTags'],
+              defined_tags: oci_tags['definedTags']
+            )
+          )
+        @stack_creation_response = response.data
+      rescue StandardError => e
+        logger.error("Error while creating stack: #{e}")
+        raise StandardError, 'Error while creating stack.'
+      end
+      @stack_creation_response
+    end
+
+    def list_jobs(stack_id)
+      # Note - :limit option return inconsistent number of results, regardless of the limit size
+      # without :limit, API returns 63 records
+      opts = { stack_id: stack_id, sort_by: 'TIMECREATED', sort_order: 'DESC' }
+      begin
+        client = Util::OCIClients.get_clients[:rms_client]
+        response = client.list_jobs(opts)
+        @list_jobs_response = response.data
+      rescue StandardError => e
+        logger.error("Error while fetching list of jobs: #{e}")
+        raise StandardError, 'Error while fetching list of jobs.'
+      end
+      @list_jobs_response
+    end
+
+    def job_status(job_id)
+      begin
+        client = Util::OCIClients.get_clients[:rms_client]
+        response = client.get_job(job_id)
+        @job_status = response.data
+      rescue StandardError => e
+        logger.error("Error while fetching stack job status: #{e}")
+        raise StandardError, 'Error while fetching stack job status.'
+      end
+      @job_status
+    end
+
+    def job_status_check(job_id, operation_timeout)
+      initial_delay_in_sec = 5
+      interval_between_checks = 10
+
+      logger.info("Checking job status. Job ID: [#{job_id}]")
+      sleep(initial_delay_in_sec)
+
+      status_check_time = Time.now.to_i
+
+      loop do
+        status_details = job_status(job_id)
+
+        lifecycle_state = status_details.lifecycle_state
+        log_msg = "#{status_details.operation} job run #{lifecycle_state.downcase}. Job OCID: #{status_details.id}, Stack OCID: #{status_details.stack_id}"
+
+        if lifecycle_state == Enum::StackJobLifecycleStateEnum::SUCCEEDED
+          logger.info(log_msg)
+          return
+        end
+
+        if not [Enum::StackJobLifecycleStateEnum::ACCEPTED, Enum::StackJobLifecycleStateEnum::IN_PROGRESS].include?(lifecycle_state)
+          logger.error("Job lifecycle state [#{lifecycle_state}] suggests termination")
+          raise StandardError, "Job lifecycle state [#{lifecycle_state}] suggests termination"
+        end
+
+        logger.info("Waiting for job to conclude. State: [#{lifecycle_state}]; Job ID: [#{job_id}]")
+        sleep(interval_between_checks)
+
+        if Time.now.to_i - status_check_time > operation_timeout
+          logger.warn("TIMEOUT: Job did not conclude within stipulated time. Job ID: [#{job_id}]")
+          break
+        end
+      end
+    end
+
+    def create_apply_job(stack_id, oci_tags)
+      operation = Enum::StackJobOperationEnum::APPLY
+      display_name = operation.downcase + '-job-' + Time.now.to_i.to_s
+
+      terraform_advanced_options = OCI::ResourceManager::Models::TerraformAdvancedOptions.new(
+        detailed_log_level: 'INFO'
+      )
+
+      job_operation_details = OCI::ResourceManager::Models::CreateApplyJobOperationDetails.new(
+        operation: operation,
+        execution_plan_strategy: 'AUTO_APPROVED',
+        is_provider_upgrade_required: true,
+        terraform_advanced_options: terraform_advanced_options
+      )
+
+      begin
+        client = Util::OCIClients.get_clients[:rms_client]
+        response = client.create_job(
+          OCI::ResourceManager::Models::CreateJobDetails.new(
+            stack_id: stack_id,
+            display_name: display_name,
+            operation: operation,
+            job_operation_details: job_operation_details,
+            freeform_tags: oci_tags['freeformTags'],
+            defined_tags: oci_tags['definedTags']
+          )
+        )
+        @job_creation_response = response.data
+      rescue StandardError => e
+        logger.error("Error while creating job: #{e}")
+        raise StandardError, 'Error while creating job.'
+      end
+      @job_creation_response
+    end
+
+    def update_stack(stack_ocid, rms_input_variables, rms_template_base64_encoded)
+      begin
+        client = Util::OCIClients.get_clients[:rms_client]
+        response = client.update_stack(stack_ocid,
+                                       OCI::ResourceManager::Models::UpdateStackDetails.new(
+                                          variables: rms_input_variables,
+                                          config_source: OCI::ResourceManager::Models::UpdateZipUploadConfigSourceDetails.new(zip_file_base64_encoded: rms_template_base64_encoded)
+                                        )
+                                      )
+        @stack_update_response = response.data
+      rescue StandardError => e
+        logger.error("Error while updating stack: #{e}")
+        raise StandardError, 'Error while updating stack.'
+      end
+      @stack_update_response
+    end
+
+    def fetch_stack_details(stack_ocid)
+      begin
+        client = Util::OCIClients.get_clients[:rms_client]
+        response = client.get_stack(stack_ocid)
+        @stack_details_response = response.data
+      rescue StandardError => e
+        logger.error("Error while retrieving stack details: #{e}")
+        raise StandardError, 'Error while retrieving stack details.'
+      end
+      @stack_details_response
+    end
+
+    def fetch_log_analytics_entity_details(oci_la_namespace, oci_la_cluster_entity_id)
+      begin
+        client = Util::OCIClients.get_clients[:la_client]
+        response = client.get_log_analytics_entity(oci_la_namespace, oci_la_cluster_entity_id)
+        @log_analytics_entity_details = response.data
+      rescue StandardError => e
+        logger.error("Error while fetching log analytics entity details: #{e}")
+        raise StandardError, 'Error while fetching log analytics entity details.'
+      end
+      @log_analytics_entity_details
+    end
+  end
+end

data/lib/util/state_manager.rb

@@ -28,6 +28,8 @@ module Util
         # therefore, events tracker configmap does not exist in cluster
         logger.info("configmap/#{@events_tracker_configmap} not found.")
         @state.last_timestamp = 0 # 1 January 1970 00:00
+        @state.retry_eligible_resources = ''
+        @state.svc_log_stack_id = ''
         begin
           Util::KubectlOps.create_configmap(@events_tracker_configmap, @namespace, @state.to_hash)
         rescue KubeException => e
@@ -37,14 +39,22 @@ module Util
         logger.info("Created new Configmap - #{@events_tracker_configmap}.")
       else
         last_timestamp = state_config_map[:data][:last_timestamp]
-        logger.info("timestamp fetched from configmap - #{last_timestamp} - #{Time.at(last_timestamp.to_i).getutc}")
+        logger.info("Timestamp fetched from configmap - #{last_timestamp} - #{Time.at(last_timestamp.to_i).getutc}")
         @state.last_timestamp = last_timestamp.to_i
+
+        retry_eligible_resource = state_config_map[:data][:retry_eligible_resources]
+        logger.debug("Non 2xx resource list fetched from configmap [#{retry_eligible_resource}]")
+        @state.retry_eligible_resources = retry_eligible_resource
+
+        svc_log_stack_id = state_config_map[:data][:svc_log_stack_id]
+        logger.debug("Service log stack OCID fetched from configmap [#{svc_log_stack_id}]")
+        @state.svc_log_stack_id = svc_log_stack_id
       end
       @is_intialized = true
     end
 
     def init_check
-      raise StandardError, 'Method call before initializig Module - StateManager' unless @is_intialized
+      raise StandardError, 'Method call before initializing Module - StateManager' unless @is_intialized
     end
 
     def state

data/lib/util/string_utils.rb

@@ -12,5 +12,53 @@ module Util
       option_selections.prepend('{')
       option_selections.concat('}')
     end
+
+    def parse_key_value_pairs(input_string)
+      result = {}
+
+      return result if input_string.nil?
+
+      pairs = input_string.split(';')
+      pairs.each do |pair|
+        key, value = pair.split(':')
+        result[key.strip] = value.strip.to_i
+      end
+      result
+    end
+
+    def to_key_value_string(hash)
+      hash.map { |key, value| "#{key}:#{value}" }.join(';')
+    end
+
+    def parse_tags_to_hash(input_string)
+      formatted_string = input_string.gsub('=', ':')
+      JSON.parse(formatted_string)
+    rescue StandardError => e
+      logger.error('Failed to parse tags. Not a valid JSON')
+      raise e
+    end
+
+    def json_key_value_pair?(json_string)
+      # Check if the parsed data is a hash
+      return false unless json_string.is_a?(Hash)
+
+      # Validate that all keys are strings
+      json_string.keys.all? { |key| key.is_a?(String) }
+      json_string.values.all? { |value| value.is_a?(String) }
+    end
+
+    def parse_defined_tags(defined_tags)
+      defined_tags.each_with_object({}) do |(key, value), result|
+        # Split the key into main key and subkey
+        main_key, sub_key = key.split('.', 2)
+
+        raise StandardError, 'Key of defined tag not formatted correctly' if main_key.nil? || sub_key.nil?
+        raise StandardError, 'Value of defined tag found to be empty' if value.nil?
+
+        # Assign the value to the nested structure
+        result[main_key] ||= {}
+        result[main_key][sub_key] = value
+      end
+    end
   end
 end

data/lib/version.rb

@@ -2,5 +2,5 @@
 ## The Universal Permissive License (UPL), Version 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 module Discovery
-  VERSION = '1.0.3'.freeze
+  VERSION = '1.1.0'.freeze
 end