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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e467bfdc3f4460d05f1eacd501b160ef847014e9fe213511a43efbb019406fca
-  data.tar.gz: 4e3d61c0fcf9fd754934814599f873d995f94b4385f04058fd1781836be8f8ac
+  metadata.gz: 40cb1255cc1125f85989f0abea5d0c6afb113327ed376c5920e2c3bc05124807
+  data.tar.gz: 2b7538d6052d87229aebdf934d51800e711d6da4017a9184c6bf0c3e236f3705
 SHA512:
-  metadata.gz: c6de2c60fc3b81c618588bcfb7d0fdf4913fed6584d22cffc68c94898f5733bd9d7278c21c9caa5079e687e87f23904bc2b24dfa1d145c21e75099e513e4afd5
-  data.tar.gz: 2ca3d0bd22bd41febf9eeec22ac58c6e78fb875267e3400f83aea7cc65d7f34a932c4d8e33a14da5db7c689d402c1d53beb078b49312446908b1bcd56165dadc
+  metadata.gz: 889778a1de60813ec7c955b027f0b5668706d6484c980cf861a4c05de76b237043dcb47ff01a841aa191b1d8fcd90a47c45ce7652574f8c2fe614faabcd264e5
+  data.tar.gz: e5d84ff26835e2102c0bc7b25f1b5e7aee4a49ac083c14c7e1d3d910af1e69dbfd97e9669cd6763b46a87661b8158c5217b10b7fe605a3ef4e8fff4a1cec8e1c

data/.gitignore

@@ -10,6 +10,7 @@
 
 ### Ruby ###
 .rspec_status
+Gemfile.lock
 
 ### IntelliJ IDEA ###
 .idea
@@ -37,4 +38,4 @@ test-run*.sh
 *.gem
 
 ### Data files ###
-*.dat
+*.dat

data/bin/oci-loganalytics-kubernetes-discovery

@@ -4,10 +4,12 @@
 ## The Universal Permissive License (UPL), Version 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 require 'optparse'
+require 'base64'
 
 require_relative '../lib/oci_loganalytics_resources_discovery'
 require_relative '../lib/util/logging'
 require_relative '../lib/util/string_utils'
+require_relative '../lib/util/helper'
 
 extend Util::Logging
 extend Util::StringUtils
@@ -20,9 +22,9 @@ app_config = {}
 DISCOVERY_OPTIONS = %w[infra object].freeze
 LOG_FMT_OPTIONS = %w[text json].freeze
 CHUNK_LIMIT_DEFAULT = 1000
+STACK_OPERATION_TIMEOUT_DEFAULT = 300 # Timeout unit is in seconds
 
 optparse = OptionParser.new do |param|
-  # TODO: Naming of the gem and command.
   param.banner = "\nUsage: oci-loganalytics-kubernetes-discovery [options]"
 
   # Mandatory Fields
@@ -34,11 +36,17 @@ optparse = OptionParser.new do |param|
   param.on('--kubernetes_resourcename_prefix PREFIX', 'Kubernetes cluster resourcename prefix. Defaults to oci-onm') { |o| cluster_config[:kubernetes_resourcename_prefix] = o }
   param.on('--kubernetes_cluster_id KUBERNETES_CLUSTER_ID', 'Unique identifier for Kubernetes cluster') { |o| cluster_config[:kubernetes_cluster_id] = o }
 
+  # OCI Auth Type
+  param.on('--auth_type AUTH_TYPE', "OCI Authentication type - #{Util::Helper.enum_values(Enum::AuthTypeEnum)}") { |o| auth_config[:auth_type] = o }
+  param.on('--oci_domain DOMAIN', 'OCI domain, ex - us-ashburn-1.oci.oraclecloud.com') { |o| auth_config[:oci_domain] = o }
+
   # OCI Config-based Auth
-  param.on('--endpoint ENDPOINT', 'Logging Analytics Ingestion API endpoint to ingest your application logs') { |o| auth_config[:endpoint] = o }
   param.on('--profile_name PROFILE_NAME', 'OCI Config Profile Name to be used from the configuration file') { |o| auth_config[:profile_name] = o }
   param.on('--config_file_location CONFIG_FILE_LOCATION', 'The location of the configuration file containing OCI authentication details') { |o| auth_config[:config_file_location] = o }
 
+  # OCI Logging Analytics custom endpoints
+  param.on('--endpoint ENDPOINT', 'Logging Analytics Ingestion API endpoint to ingest your application logs') { |o| auth_config[:endpoint] = o }
+
   # Kubernetes Cluster
   # For AuthNAuth when the job is outside the cluster.
   param.on('--kube_config_location KUBE_CONFIG_LOCATION', 'Path to the kubernetes configuration (kubeconfig) file') { |o| kube_config[:kube_config_location] = o }
@@ -53,10 +61,18 @@ optparse = OptionParser.new do |param|
   param.on('--secret_dir SECRET_DIR', 'Path to Kubernetes service account token file to access Kubernetes API') { |o| kube_config[:secret_dir] = o }
 
   # Discovery
-  param.on('--discovery DISCOVERY_MODE', "Discovery mode to be used: #{format_option_selections(DISCOVERY_OPTIONS)}") { |o| app_config[:mode] = o.downcase }
+  param.on('--discovery DISCOVERY_MODE', "[Deprecated] Discovery mode to be used: #{format_option_selections(DISCOVERY_OPTIONS)}") { |o| app_config[:mode] = o.downcase }
   param.on('--chunk_limit CHUNK_SIZE', Integer, "Max number of objects that can be fetched via K8s GET API call. Default: #{CHUNK_LIMIT_DEFAULT}") { |o| app_config[:chunk_limit] = o }
   param.on('--skip_upload', 'Flag to skip uploading data to OCI Logging Analytics [ONLY FOR INTERNAL TESTING]') { |_o| app_config[:skip_upload] = true }
   param.on('--collect_warning_events_only', 'Flag to collect only warning event logs') { |_o| app_config[:collect_warning_events_only] = true }
+  param.on('--tenancy_ocid TENANCY_OCID', 'Tenancy OCID') { |o| app_config[:tenancy_ocid] = o }
+
+  # Stack operations
+  param.on('--rms_template_base64_encoded RMS_TEMPLATE_BASE64_ENCODED', 'Base64 encoded ZIP file of RMS template for OCI service log collection') { |o| app_config[:rms_template_base64_encoded] = o }
+  param.on('--stack_operation_timeout STACK_OPERATION_TIMEOUT', "Maximum amount of time (in seconds) the job should wait while checking the status of stack APPLY operation. Default: #{STACK_OPERATION_TIMEOUT_DEFAULT}") { |o| app_config[:stack_operation_timeout] = o }
+  param.on('--enable_service_log', 'Flag to enable or disable the creation of a stack for collecting OCI service logs associated with OKE cluster') { |_o| app_config[:enable_service_log] = true }
+  param.on('--oci_tags_base64 OCI_TAGS_BASE64', 'Freeform and defined tags provided to the job') { |o| app_config[:oci_tags] = o }
+  param.on('--probe_all_compartments', 'Flag that determines whether to iterate through all compartments or only the cluster compartment while discovering node pools') { |_o| app_config[:probe_all_compartments] = true }
 
   # Logging and threading
   param.on('--log_format LOG_FORMAT', "Log format to be used: #{format_option_selections(LOG_FMT_OPTIONS)}") { |o| app_config[:log_format] = o }
@@ -83,16 +99,19 @@ begin
   missing = mandatory.select { |param| cluster_config[param].nil? || cluster_config[param].empty? } # .empty gates 'key=' edge case
   raise OptionParser::MissingArgument, missing.join(', ') unless missing.empty?
 
-  # Valid discovery mode check.
-  unless app_config[:mode].nil?
-    unless DISCOVERY_OPTIONS.include? app_config[:mode]
-      raise OptionParser::InvalidOption, "--discovery=#{app_config[:mode]}"
+  if app_config[:enable_service_log] && app_config[:rms_template_base64_encoded].nil?
+    logger.error('RMS template must be provided for infrastructure discovery when OCI service log creation is enabled.')
+    raise OptionParser::MissingArgument, '--rms_template_base64_encoded'
+  end
+
+  # Valid auth input check.
+  unless auth_config[:auth_type].nil?
+    unless Util::Helper.enum_value_defined?(Enum::AuthTypeEnum, auth_config[:auth_type])
+      raise OptionParser::InvalidOption, "--auth_type #{auth_config[:auth_type]} | valid inputs - #{Util::Helper.enum_values(Enum::AuthTypeEnum)}"
     end
 
-    # Threads valid only for object discovery (not for infrastrucutre discovery).
-    if app_config[:mode] == DISCOVERY_OPTIONS.first && app_config[:enable_threading]
-      logger.info("Multi-threading is only supported for mode: #{DISCOVERY_OPTIONS.second}")
-      raise OptionParser::InvalidOption, '--enable_threading'
+    if auth_config[:auth_type] == Enum::AuthTypeEnum::CONFIG
+      raise OptionParser::MissingArgument, '--config_file_location' if auth_config[:config_file_location].nil?
     end
   end
 
@@ -104,23 +123,63 @@ begin
   if app_config[:chunk_limit] && app_config[:chunk_limit] > 10_000
     raise OptionParser::InvalidOption, '--chunk_limit is too large.'
   end
-rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
-  logger.info(e.to_s.capitalize)
+
+  # Validate freeform tags and defined tags
+  begin
+    if !app_config[:oci_tags].nil? && !app_config[:oci_tags].empty?
+      app_config[:oci_tags_str] = Base64.decode64(app_config[:oci_tags])
+      app_config[:oci_tags_json] = parse_tags_to_hash(app_config[:oci_tags_str])
+
+      freeform_tags = app_config[:oci_tags_json]['freeformTags']
+      defined_tags = app_config[:oci_tags_json]['definedTags']
+
+      if !freeform_tags.nil?
+        raise StandardError, 'Freeform tags should be string key-value pairs' if !json_key_value_pair?(freeform_tags)
+      end
+
+      if !defined_tags.nil?
+        raise StandardError, 'Defined tags should be string key-value pairs' if !json_key_value_pair?(defined_tags)
+        app_config[:oci_tags_json]['definedTags'] = parse_defined_tags(defined_tags)
+      end
+    end
+  rescue StandardError => e
+    logger.error("Error: #{e.message}")
+    raise OptionParser::InvalidArgument, 'Invalid format for --oci_tags. Ensure it follows the correct structure.'
+  end
+
+  # Tenancy OCID is compulsory if probe_all_compartments flag is set
+  if app_config[:probe_all_compartments] && app_config[:tenancy_ocid].nil?
+    logger.error('Tenancy OCID is compulsory if --probe_all_compartments is provided')
+    raise OptionParser::MissingArgument, '--tenancy_ocid'
+  end
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument, OptionParser::InvalidArgument => e
+  logger.error(e.to_s.capitalize)
   logger.info(optparse)
   exit(1)
 end
 
 # Set defaults for skipped inputs
-
 cluster_config[:kubernetes_cluster_id] = cluster_config[:kubernetes_cluster_id] ||= nil
 cluster_config[:oci_la_cluster_entity_id] = cluster_config[:oci_la_cluster_entity_id] ||= nil
 cluster_config[:kubernetes_resourcename_prefix] = cluster_config[:kubernetes_resourcename_prefix] ||= 'oci-onm'
 
+# OCI Auth Type
+if !auth_config[:config_file_location].nil?
+  auth_config[:auth_type] = auth_config[:auth_type] ||=  Enum::AuthTypeEnum::CONFIG
+else
+  auth_config[:auth_type] = auth_config[:auth_type] ||=  Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+end
+
+# OCI Domain
+auth_config[:oci_domain] = auth_config[:oci_domain] ||= nil
+
 # Config based auth
-auth_config[:endpoint] = auth_config[:endpoint] ||= nil
 auth_config[:profile_name] = auth_config[:profile_name] ||= 'DEFAULT'
 auth_config[:config_file_location] = auth_config[:config_file_location] ||= nil
 
+# OCI Logging Analytics custom endpoints
+auth_config[:endpoint] = auth_config[:endpoint] ||= nil
+
 # Kubernetes cluster related
 kube_config[:kube_config_location] = kube_config[:kube_config_location] ||= nil
 kube_config[:kubernetes_url] = kube_config[:kubernetes_url] ||= nil
@@ -134,21 +193,46 @@ kube_config[:bearer_token_file] = kube_config[:bearer_token_file] ||= nil
 kube_config[:secret_dir] = kube_config[:secret_dir] ||= '/var/run/secrets/kubernetes.io/serviceaccount'
 
 # Discovery
-app_config[:mode] = app_config[:mode] ||= 'object'
 app_config[:skip_upload] = app_config[:skip_upload] ||= false
 app_config[:collect_warning_events_only] = app_config[:collect_warning_events_only] ||= false
 app_config[:chunk_limit] = app_config[:chunk_limit] ||= CHUNK_LIMIT_DEFAULT
+app_config[:tenancy_ocid] = app_config[:tenancy_ocid] ||= nil
+app_config[:stack_operation_timeout] = app_config[:stack_operation_timeout] ||= STACK_OPERATION_TIMEOUT_DEFAULT
+
+# Stack operations
+app_config[:oci_tags_str] = app_config[:oci_tags_str].nil? || app_config[:oci_tags_str].empty? ? '{ "freeformTags" = {}, "definedTags" = {} }' : app_config[:oci_tags_str]
+app_config[:oci_tags_json] = app_config[:oci_tags_json].nil? || app_config[:oci_tags_json].empty? ? { freeformTags: {}, definedTags: {} } : app_config[:oci_tags_json]
+app_config[:probe_all_compartments] = app_config[:probe_all_compartments] ||= false
 
 # Threading
 app_config[:enable_threading] = app_config[:enable_threading] ||= false
 app_config[:thread_count] = app_config[:thread_count] ||= 1
 app_config[:work_queue_size] = app_config[:work_queue_size] ||= (app_config[:thread_count] * 5)
 
-# Log level and format provided in arguement
+# Log level and format provided in argument
 app_config[:log_format] = app_config[:log_format] ||= LOG_FMT_OPTIONS.first
 app_config[:log_level] = !app_config[:log_level].nil? ? Util::Logging::SEV_LABEL.key(app_config[:log_level].upcase) : Logger::INFO
 app_config[:enable_raw_request] = app_config[:enable_raw_request] ||= false
 
+# Decide on Service and Infra discovery based on input
+if cluster_config[:kubernetes_cluster_id].nil?
+  if app_config[:enable_service_log]
+    logger.warn('Service Discovery is only supported for OKE. OCI service logs collection will be skipped.')
+    cluster_config[:enable_infra_discovery] = false
+  end
+  logger.warn('Kubernetes cluster ID is missing. Infrastructure discovery will be skipped.')
+  app_config[:enable_service_log] = false
+elsif !cluster_config[:kubernetes_cluster_id].match?("ocid1\.cluster")
+  if app_config[:enable_service_log]
+    logger.warn('Service Discovery is only supported for OKE. OCI service logs collection will be skipped.')
+    cluster_config[:enable_infra_discovery] = false
+  end
+  logger.warn('Infra Discovery is only supported for OKE. Infrastructure discovery will be skipped.')
+  app_config[:enable_service_log] = false
+else
+  cluster_config[:enable_infra_discovery] = true
+end
+
 Util::Logging::LogConfigs.new(app_config[:log_format], app_config[:log_level])
 
 logger.info('Initiating Kubernetes Discovery.')
@@ -162,14 +246,7 @@ begin
     app_config_hash: app_config
   )
 
-  case app_config[:mode]
-  when 'infra'
-    # Initiating Kubernetes infrastructure discovery
-    OciLogAnalyticsResourcesDiscovery.initiate_infra_discovery
-  when 'object'
-    # Initiating Kubernetes objects discovery
-    OciLogAnalyticsResourcesDiscovery.initiate_object_discovery
-  end
+  OciLogAnalyticsResourcesDiscovery.initiate_discovery
 rescue StandardError => e
   unless e.backtrace.empty?
     stack_trace = "\n"

data/lib/config/oci_client_retry_config.rb

@@ -9,13 +9,15 @@ module Config
 
     module_function
 
-    attr_accessor :retry_config
+    def oci_default_retry_config
+      OCI::Retry.default_retry_config
+    end
 
-    def set_default_retry_config
+    def custom_retry_policy
       OCI::Retry::RetryConfig.new(
         base_sleep_time_millis: 1000,
         exponential_growth_factor: 2,
-        should_retry_exception_proc: OCI::Retry::Functions::ShouldRetryOnError.retry_on_network_error_throttle_and_internal_server_errors,
+        should_retry_exception_proc: retry_on_4xx_and_5xx,
         sleep_calc_millis_proc: OCI::Retry::Functions::Sleep.exponential_backoff_with_full_jitter,
         max_attempts: 5,
         max_elapsed_time_millis: 300_000, # 5 minutes
@@ -23,12 +25,13 @@ module Config
       )
     end
 
-    def set_custom_retry_config(custom_retry_config)
-      @retry_config = custom_retry_config
-    end
+    def retry_on_4xx_and_5xx
+      lambda do |retry_state|
+        return true if retry_state.last_exception.is_a?(OCI::Errors::NetworkError)
+        return false unless retry_state.last_exception.is_a?(OCI::Errors::ServiceError)
 
-    def get_retry_config
-      @retry_config.nil? ? set_default_retry_config : @retry_config
+        retry_state.last_exception.status_code >= 400
+      end
     end
   end
 end

data/lib/discover/infrastructure.rb

@@ -1,9 +1,11 @@
 ## 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 '../util/logging'
+require 'oci'
+require 'json'
 
 # Util
+require_relative '../util/logging'
 require_relative '../util/oci_clients'
 
 module Discover
@@ -13,7 +15,7 @@ module Discover
 
     module_function
 
-    def fetch_cluster_details(_auth_object, cluster_id)
+    def fetch_cluster_details(cluster_id)
       client = nil
       begin
         client = Util::OCIClients.get_clients[:ce_client]
@@ -23,63 +25,93 @@ module Discover
       rescue StandardError => e
         logger.error("Error while discovering cluster details: #{e}")
         raise StandardError, 'Error while discovering cluster details.'
-        exit
       end
       @cluster_details
     end
 
-    def fetch_node_pool_lists(_auth_object, compartment_id, cluster_id)
-      opts = { cluster_id: cluster_id }
+    def fetch_node_pool_lists(compartment_id, cluster_id)
+      opts = { cluster_id: cluster_id, limit: 1000 }
       begin
         client = Util::OCIClients.get_clients[:ce_client]
+
+        # NOTE: The below call retrieves only the first page of the node pool list. Pagination support is
+        # not implemented because the first page already contains up to 1000 records (Check limit above)
+        # which is sufficient for our current use case. Subsequent pages will not be fetched.
         response = client.list_node_pools(compartment_id, opts)
 
         @node_pool_list = response.data
       rescue StandardError => e
         logger.error("Error while discovering node pool list: #{e}")
         raise StandardError, 'Error while discovering node pool list.'
-        exit
       end
       @node_pool_list
     end
 
-    def fetch_compartment_list(_auth_object, compartment_id)
+    def fetch_node_pool(node_pool_id)
+      begin
+        client = Util::OCIClients.get_clients[:ce_client]
+        response = client.get_node_pool(node_pool_id)
+
+        @node_pool_details = response.data
+      rescue StandardError => e
+        logger.error("Error while fetching node pool details: #{e}")
+        raise StandardError, 'Error while fetching node pool details.'
+      end
+      @node_pool_details
+    end
+
+    def fetch_compartment_list(compartment_id, scoped_at_tenancy)
       client = nil
-      opts = { compartment_id_in_subtree: true, access_level: 'ANY' }
+      all_records = []
+
       begin
         client = Util::OCIClients.get_clients[:id_client]
+
+        opts = if scoped_at_tenancy
+                 { compartment_id_in_subtree: true, access_level: 'ACCESSIBLE' }
+               else
+                 { access_level: 'ACCESSIBLE' }
+               end
+
         response = client.list_compartments(compartment_id, opts)
+        all_records.concat(response.data)
 
-        @id_response = response.data
+        while !response.next_page.nil?
+          opts[:page] = response.next_page
+          response = client.list_compartments(compartment_id, opts)
+          all_records.concat(response.data)
+        end
       rescue StandardError => e
-        logger.error("Error while fetching load balancer details: #{e}")
-        raise StandardError, 'Error while fetching load balancer details.'
+        logger.error("Error while fetching compartment list: #{e}")
+        raise StandardError, 'Error while fetching compartment list.'
       end
-      @id_response
+      return { data: all_records, status: response.status }
     end
 
-    def fetch_load_balancer_details(_auth_object, load_balancer_id)
+    def fetch_load_balancer_details(load_balancer_id)
       client = nil
       begin
         client = Util::OCIClients.get_clients[:lb_client]
         response = client.get_load_balancer(load_balancer_id)
-        @lb_response = response.data
+        @lb_response = response
       rescue StandardError => e
         logger.error("Error while fetching load balancer details: #{e}")
+        return { data: nil, status: e.status_code } unless e.status_code.nil?
+
         raise StandardError, 'Error while fetching load balancer details.'
       end
-      @lb_response
+      { data: @lb_response.data, status: @lb_response.status }
     end
 
-    def fetch_free_text_details(_auth_object, cluster_id)
+    def search_with_free_text(free_text)
       client = nil
       begin
-        client = Util::OCIClients.get_clients[:rs_client]
+        client = Util::OCIClients.get_clients[:rqs_client]
         response = client.search_resources(
           OCI::ResourceSearch::Models::FreeTextSearchDetails.new(
             type: 'FreeText',
-            text: cluster_id,
-            matchingContextType: 'HIGHLIGHTS'
+            text: free_text,
+            matching_context_type: OCI::ResourceSearch::Models::SearchDetails::MATCHING_CONTEXT_TYPE_HIGHLIGHTS
           )
         )
         @free_text_response = response.data
@@ -90,33 +122,53 @@ module Discover
       @free_text_response
     end
 
-    def fetch_vcn_response(_auth_object, vcn_id)
+    def search_with_structured_query(query)
       client = nil
       begin
-        client = Util::OCIClients.get_clients[:vnc_client]
+        client = Util::OCIClients.get_clients[:rqs_client]
+        response = client.search_resources(
+          OCI::ResourceSearch::Models::StructuredSearchDetails.new(
+            type: 'Structured',
+            query: query,
+            matching_context_type: OCI::ResourceSearch::Models::SearchDetails::MATCHING_CONTEXT_TYPE_HIGHLIGHTS
+          )
+        )
+        @structured_query_response = response.data
+      rescue StandardError => e
+        logger.error("Error while fetching structured query: #{e}")
+        raise StandardError, 'Error while fetching structured query.'
+      end
+      @structured_query_response
+    end
+
+    def fetch_vcn_response(vcn_id)
+      client = nil
+      begin
+        client = Util::OCIClients.get_clients[:vcn_client]
         response = client.get_vcn(vcn_id)
 
         @vnc_response = response.data
       rescue StandardError => e
-        logger.error("Error while discovering VNC details: #{e}")
-        raise StandardError, 'Error while discovering VNC details.'
+        logger.error("Error while discovering VCN details: #{e}")
+        raise StandardError, 'Error while discovering VCN details.'
       end
       @vnc_response
     end
 
-    def fetch_subnet_list_response(_auth_object, compartment_id, vcn_id)
+    def fetch_subnet_details(subnet_id)
       client = nil
       begin
-        opts = { vcn_id: vcn_id }
-        client = Util::OCIClients.get_clients[:vnc_client]
-        response = client.list_subnets(compartment_id, opts)
+        client = Util::OCIClients.get_clients[:vcn_client]
+        response = client.get_subnet(subnet_id)
 
-        @subnet_response = response.data
+        @subnet_response = response
       rescue StandardError => e
         logger.error("Error while discovering subnet details: #{e}")
+        return { data: nil, status: e.status_code } unless e.status_code.nil?
+
         raise StandardError, 'Error while discovering subnet details.'
       end
-      @subnet_response
+      { data: @subnet_response.data, status: @subnet_response.status }
     end
   end
 end

data/lib/discover/object.rb

@@ -21,9 +21,9 @@ module Discover
     End_point_slice = Struct.new(:name, :namespace, :uid, :endpoints, :ports)
     Job = Struct.new(:name, :namespace, :uid, :controller)
     Node = Struct.new(:name, :displayName, :uid, :internalIP, :externalIP)
-    Pod = Struct.new(:name, :namespace, :uid, :podIP, :hostIP, :nodeIP, :controller)
+    Pod = Struct.new(:name, :namespace, :uid, :podIP, :hostIP, :nodeIP, :controller, :phase, :startTime, :finishTime)
     Replica_set = Struct.new(:name, :namespace, :uid, :controller)
-    Service = Struct.new(:name, :namespace, :uid, :clusterIP, :externalIP, :loadBalancerIP, :ports)
+    Service = Struct.new(:name, :namespace, :uid, :clusterIP, :externalIP, :loadBalancerIP, :serviceType, :ports)
     Namespace = Struct.new(:name, :uid)
 
     def get_generic_object_details(item, object_type)
@@ -200,6 +200,8 @@ module Discover
           podIP = item[:status][:podIP]
           hostIP = item[:status][:hostIP]
           nodeIP = item[:status][:nodeIP]
+          phase =  item[:status][:phase]
+          startTime =  item[:status][:startTime]
           controller = nil
           if !item[:metadata][:ownerReferences].nil? && !item[:metadata][:ownerReferences].empty?
             item[:metadata][:ownerReferences].each do |owner_reference|
@@ -210,7 +212,18 @@ module Discover
               end
             end
           end
-          processed_data.push(Pod.new(generic_object[:name], generic_object[:namespace], generic_object[:uid], podIP, hostIP, nodeIP, controller.to_h))
+          finishTime = nil
+          if !item[:status][:containerStatuses].nil? && !item[:status][:containerStatuses].empty?
+            item[:status][:containerStatuses].each do |container_status|
+              next if container_status.nil?
+
+              if !container_status[:state][:terminated].nil?
+                finishTime = container_status[:state][:terminated][:finishedAt]
+              end
+            end
+          end
+          processed_data.push(Pod.new(generic_object[:name], generic_object[:namespace], generic_object[:uid],
+           podIP, hostIP, nodeIP, controller.to_h, phase, startTime, finishTime))
         end
       rescue StandardError => e
         logger.error("Unable to fetch '#{resource_name}'")
@@ -259,6 +272,8 @@ module Discover
           clusterIP = item[:spec][:clusterIP]
           externalIP = item[:spec][:externalIP]
           loadBalancerIP = item[:status][:loadBalancer][:ingress].nil? ? nil : item[:status][:loadBalancer][:ingress][0][:ip]
+          service_type = item[:spec][:type]
+
           ports = item[:spec][:ports]
           ports_arr = []
           if !ports.nil? && !ports.empty?
@@ -268,7 +283,7 @@ module Discover
               ports_arr.push(port_item.to_h)
             end
           end
-          processed_data.push(Service.new(generic_object[:name], generic_object[:namespace], generic_object[:uid], clusterIP, externalIP, loadBalancerIP, ports_arr))
+          processed_data.push(Service.new(generic_object[:name], generic_object[:namespace], generic_object[:uid], clusterIP, externalIP, loadBalancerIP, service_type, ports_arr))
         end
       rescue StandardError => e
         logger.error("Unable to fetch '#{resource_name}'")

data/lib/dto/infra/load_balancer_payload.rb

@@ -0,0 +1,32 @@
+## 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/
+
+module Dto
+  module Infra
+    class LoadBalancerPayload
+      attr_accessor :name, :ocid, :compartment_id, :is_private, :ip_addresses, :lifecycle_state, :subnet_ids
+
+      def initialize(name, ocid, compartment_id, is_private, ip_addresses, lifecycle_state, subnet_ids)
+        @name = name
+        @ocid = ocid
+        @compartment_id = compartment_id
+        @is_private = is_private
+        @ip_addresses = ip_addresses
+        @lifecycle_state = lifecycle_state
+        @subnet_ids = subnet_ids
+      end
+
+      def to_hash
+        {
+          name: @name,
+          ocid: @ocid,
+          compartmentId: @compartment_id,
+          isPrivate: @is_private,
+          ipAddresses: @ip_addresses.map(&:to_h),
+          lifecycleState: @lifecycle_state,
+          subnetIds: @subnet_ids
+        }.compact
+      end
+    end
+  end
+end

data/lib/dto/infra/node_pool_payload.rb

@@ -0,0 +1,28 @@
+## 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/
+
+module Dto
+  module Infra
+    class NodePoolPayload
+      attr_accessor :name, :ocid, :compartment_id, :subnet_ids, :nodes
+
+      def initialize(name, ocid, compartment_id, subnet_ids, nodes)
+        @name = name
+        @ocid = ocid
+        @compartment_id = compartment_id
+        @subnet_ids = subnet_ids
+        @nodes = nodes
+      end
+
+      def to_hash
+        {
+          name: @name,
+          ocid: @ocid,
+          compartmentId: @compartment_id,
+          subnetIds: @subnet_ids,
+          nodes: @nodes.map(&:to_h)
+        }.compact
+      end
+    end
+  end
+end

data/lib/dto/infra/{node_pool_entity_payload.rb → resource_payload.rb}

@@ -3,20 +3,20 @@
 
 module Dto
   module Infra
-    class NodePoolEntityPayload
-      attr_accessor :name, :id, :compartment_id
+    class ResourcePayload
+      attr_accessor :name, :ocid, :compartment_id
 
-      def initialize(name, id, compartment_id)
+      def initialize(name, ocid, compartment_id)
         @name = name
-        @id = id
+        @ocid = ocid
         @compartment_id = compartment_id
       end
 
       def to_hash
         {
           name: @name,
-          id: @id,
-          compartment_id: @compartment_id
+          ocid: @ocid,
+          compartmentId: @compartment_id
         }.compact
       end
     end

data/lib/dto/infra/subnet_payload.rb

@@ -0,0 +1,34 @@
+## 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/
+
+module Dto
+  module Infra
+    class SubnetPayload
+      attr_accessor :name, :ocid, :compartment_id, :prohibit_internet_ingress, :prohibit_public_ip_on_vnic,
+                    :cidr_block, :lifecycle_state
+
+      def initialize(name, ocid, compartment_id, prohibit_internet_ingress, prohibit_public_ip_on_vnic,
+                     cidr_block, lifecycle_state)
+        @name = name
+        @ocid = ocid
+        @compartment_id = compartment_id
+        @prohibit_internet_ingress = prohibit_internet_ingress
+        @prohibit_public_ip_on_vnic = prohibit_public_ip_on_vnic
+        @cidr_block = cidr_block
+        @lifecycle_state = lifecycle_state
+      end
+
+      def to_hash
+        {
+          name: @name,
+          ocid: @ocid,
+          compartmentId: @compartment_id,
+          prohibitInternetIngress: @prohibit_internet_ingress,
+          prohibitPublicIpOnVnic: @prohibit_public_ip_on_vnic,
+          cidrBlock: @cidr_block,
+          lifecycleState: @lifecycle_state
+        }.compact
+      end
+    end
+  end
+end