oci-logging-analytics-kubernetes-discovery 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 91e5befbfc8bd2e885d9965cc8dcf9fcf52d8efb
+  data.tar.gz: f54c28695b070ad4566cfe0320f713fd71a1ed30
+SHA512:
+  metadata.gz: 7122da1196e19892247ed00fe61a14490b9cc43c1a4a810c76275ec808978fc7db40281b2b5b0312af10bf616f11a8abb60fdc20fa1e044973d784a46a44dd56
+  data.tar.gz: 353ad156e28982d160fb8b977b064de2768ef024409d893cfe79df6dbb8ca40c93db4d2a43d72143620b6d22227dcca2d72a6326c2aa18b09c55bfe8012d4852

data/.gitignore

@@ -0,0 +1,40 @@
+### Project Binaries ###
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+### Ruby ###
+.rspec_status
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Development Test scripts ###
+test-run*.sh
+
+### Gems ###
+*.gem
+
+### Data files ###
+*.dat

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.0
+before_install: gem install bundler -v 2.1.2

data/Gemfile

@@ -0,0 +1,7 @@
+## 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/
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oci-logging-analytics-kubernetes-discovery.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,36 @@
+Copyright (c) 2024  Oracle and/or its affiliates.
+
+The Universal Permissive License (UPL), Version 1.0
+
+Subject to the condition set forth below, permission is hereby granted to any
+person obtaining a copy of this software, associated documentation and/or data
+(collectively the "Software"), free of charge and under any and all copyright
+rights in the Software, and any and all patent rights owned or freely
+licensable by each licensor hereunder covering either (i) the unmodified
+Software as contributed to or provided by such licensor, or (ii) the Larger
+Works (as defined below), to deal in both
+
+(a) the Software, and
+(b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+one is included with the Software (each a "Larger Work" to which the Software
+is contributed by such licensors),
+
+without restriction, including without limitation the rights to copy, create
+derivative works of, display, perform, and distribute the Software and make,
+use, sell, offer for sale, import, export, have made, and have sold the
+Software and the Larger Work(s), and to sublicense the foregoing rights on
+either these or other terms.
+
+This license is subject to the following condition:
+
+The above copyright notice and either this complete permission notice or at
+a minimum a reference to the UPL must be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+# OCI Logging Analytics Kubernetes Discovery
+
+## Overview
+
+A rubygem for discovering Kubernetes resources and send it to OCI Logging Analytics.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'oci-logging-analytics-kubernetes-discovery'
+```
+
+And then execute:
+
+```shell
+$ bundle install
+```
+
+Or install it yourself as:
+
+```ruby
+$ gem install oci-logging-analytics-kubernetes-discovery
+```
+
+## Usage
+
+```
+Usage: oci-loganalytics-kubernetes-discovery [options]
+        --oci_la_namespace OCI_LA_NAMESPACE
+                                     OCI Tenancy Namespace to which the collected log data is to be uploaded
+        --oci_la_log_group_id OCI_LA_LOG_GROUP_ID
+                                     OCID of Logging Analytics Log Group to which the uploaded data is to be associated with
+        --oci_la_cluster_entity_id KUBERNETES_CLUSTER_ENTITY_ID
+                                     OCID of Logging Analytics Kubernetes Cluster entity
+        --kubernetes_cluster_name KUBERNETES_CLUSTER_NAME
+                                     A unique name for each kubernetes cluster must be provided
+        --kubernetes_cluster_namespace KUBERNETES_CLUSTER_NAMESPACE
+                                     Kubernetes namespace in which the discovery job is configured
+        --kubernetes_resourcename_prefix PREFIX
+                                     Kubernetes cluster resourcename prefix. Defaults to oci-onm
+        --kubernetes_cluster_id KUBERNETES_CLUSTER_ID
+                                     Unique identifier for Kubernetes cluster
+        --endpoint ENDPOINT          Logging Analytics Ingestion API endpoint to ingest your application logs
+        --profile_name PROFILE_NAME  OCI Config Profile Name to be used from the configuration file
+        --config_file_location CONFIG_FILE_LOCATION
+                                     The location of the configuration file containing OCI authentication details
+        --kube_config_location KUBE_CONFIG_LOCATION
+                                     Path to the kubernetes configuration (kubeconfig) file
+        --kubernetes_url KUBERNETES_URL
+                                     Kubernetes API server URL. Alternatively, environment variables KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT can be used
+        --client_cert CLIENT_CERT    Path to certificate file for Kubernetes HTTPs/SSL server certificate validation
+        --client_key CLIENT_KEY      Path to key for Kubernetes HTTPs/SSL server certificate validation
+        --ca_file CA_FILE            Path to CA file for Kubernetes HTTPs/SSL server certificate validation
+        --verify_ssl                 Validate SSL certificates while creating kube clients
+        --bearer_token_file BEARER_TOKEN_FILE
+                                     Path to bearer token file if basic authentication is used
+        --secret_dir SECRET_DIR      Path to Kubernetes service account token file to access Kubernetes API
+        --discovery DISCOVERY_MODE   Discovery mode to be used: {infra|object}
+        --chunk_limit CHUNK_SIZE     Max number of objects that can be fetched via K8s GET API call. Default: 1000
+        --skip_upload                Flag to skip uploading data to OCI Logging Analytics [ONLY FOR INTERNAL TESTING]
+        --collect_warning_events_only
+                                     Flag to collect only warning event logs
+        --log_format LOG_FORMAT      Log format to be used: {text|json}
+        --log_level LOG_LEVEL        User defined log level: {trace|debug|info|warn|error|fatal}
+        --enable_threading           Defaults to sequential execution when parameter is not provided
+        --thread_count THREAD_COUNT  Number of parallel threads to be used while making requests to API server
+        --enable_raw_request         If set, signs the raw request while uploading payloads to Discovery API. The default behavior is to use OCI Ruby SDK
+        --help                       Print complete help information and exit
+```
+
+## License
+
+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/.
+
+See [LICENSE](LICENSE.txt) for more details.
+
+## Re-distribution Note
+
+If you need to re-distribute this as part of any other binary, you may need to ensure including all the necessary [runtime dependencies](oci-logging-analytics-kubernetes-discovery.gemspec) along with their transitive dependencies. Also, you may need to take care of the necessary attributions as required.

data/Rakefile

@@ -0,0 +1,15 @@
+## 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 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  # Adds the tests directory to the lists of directories in the #$LOADPATH
+  t.libs << 'tests'
+
+  # Creates a list of files that match 'test/*_test.rb'
+  t.test_files = FileList['test/*_test.rb']
+
+  # If you want your tests to output what they should do, then set this to true.
+  t.verbose = true
+end

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+## 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 'bundler/setup'
+require 'oci-logging-analytics-kubernetes-discovery'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/oci-loganalytics-kubernetes-discovery

@@ -0,0 +1,184 @@
+#!/usr/bin/env ruby
+
+## 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 'optparse'
+
+require_relative '../lib/oci_loganalytics_resources_discovery'
+require_relative '../lib/util/logging'
+require_relative '../lib/util/string_utils'
+
+extend Util::Logging
+extend Util::StringUtils
+
+cluster_config = {}
+auth_config = {}
+kube_config = {}
+app_config = {}
+
+DISCOVERY_OPTIONS = %w[infra object].freeze
+LOG_FMT_OPTIONS = %w[text json].freeze
+CHUNK_LIMIT_DEFAULT = 1000
+
+optparse = OptionParser.new do |param|
+  # TODO: Naming of the gem and command.
+  param.banner = "\nUsage: oci-loganalytics-kubernetes-discovery [options]"
+
+  # Mandatory Fields
+  param.on('--oci_la_namespace OCI_LA_NAMESPACE', 'OCI Tenancy Namespace to which the collected log data is to be uploaded') { |o| cluster_config[:oci_la_namespace] = o }
+  param.on('--oci_la_log_group_id OCI_LA_LOG_GROUP_ID', 'OCID of Logging Analytics Log Group to which the uploaded data is to be associated with') { |o| cluster_config[:oci_la_log_group_id] = o }
+  param.on('--oci_la_cluster_entity_id KUBERNETES_CLUSTER_ENTITY_ID', 'OCID of Logging Analytics Kubernetes Cluster entity') { |o| cluster_config[:oci_la_cluster_entity_id] = o }
+  param.on('--kubernetes_cluster_name KUBERNETES_CLUSTER_NAME', 'A unique name for each kubernetes cluster must be provided') { |o| cluster_config[:kubernetes_cluster_name] = o }
+  param.on('--kubernetes_cluster_namespace KUBERNETES_CLUSTER_NAMESPACE', 'Kubernetes namespace in which the discovery job is configured') { |o| cluster_config[:kubernetes_cluster_namespace] = o }
+  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 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 }
+
+  # 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 }
+  param.on('--kubernetes_url KUBERNETES_URL', 'Kubernetes API server URL. Alternatively, environment variables KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT can be used') { |o| kube_config[:kubernetes_url] = o }
+  # For AuthNAuth when the job is within the same cluster.
+  param.on('--client_cert CLIENT_CERT', 'Path to certificate file for Kubernetes HTTPs/SSL server certificate validation') { |o| kube_config[:client_cert] = o }
+  param.on('--client_key CLIENT_KEY', 'Path to key for Kubernetes HTTPs/SSL server certificate validation') { |o| kube_config[:client_key] = o }
+  param.on('--ca_file CA_FILE', 'Path to CA file for Kubernetes HTTPs/SSL server certificate validation') { |o| kube_config[:ca_file] = o }
+  param.on('--verify_ssl', 'Validate SSL certificates while creating kube clients') { |_o| kube_config[:verify_ssl] = true }
+  # For AuthNAuth using bearer token.
+  param.on('--bearer_token_file BEARER_TOKEN_FILE', 'Path to bearer token file if basic authentication is used') { |o| kube_config[:bearer_token_file] = o }
+  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('--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 }
+
+  # 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 }
+  param.on('--log_level LOG_LEVEL', "User defined log level: #{format_option_selections(Util::Logging::SEV_LABEL.values)}") { |o| app_config[:log_level] = o }
+  param.on('--enable_threading', 'Defaults to sequential execution when parameter is not provided') { |o| app_config[:enable_threading] = o }
+  param.on('--thread_count THREAD_COUNT', Integer, 'Number of parallel threads to be used while making requests to API server') { |o| app_config[:thread_count] = o }
+  param.on('--enable_raw_request', 'If set, signs the raw request while uploading payloads to Discovery API. The default behavior is to use OCI Ruby SDK') { |o| app_config[:enable_raw_request] = o }
+
+  param.on('--help', 'Print complete help information and exit') do
+    puts param
+    exit
+  end
+end
+
+# Initial logging configs (format is 'text', level is 'info').
+Util::Logging::LogConfigs.new(LOG_FMT_OPTIONS.first, Logger::INFO)
+
+# Argument Validations
+begin
+  optparse.parse!
+
+  # Check if mandatory arguments are missing.
+  mandatory = %i[oci_la_namespace oci_la_log_group_id kubernetes_cluster_id kubernetes_cluster_name kubernetes_cluster_namespace]
+  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]}"
+    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'
+    end
+  end
+
+  # If threads are enabled, thread count and queue size should be provided as arguments.
+  if app_config[:enable_threading] && app_config[:thread_count].nil?
+    raise OptionParser::MissingArgument, '--thread_count'
+  end
+
+  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)
+  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'
+
+# 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
+
+# Kubernetes cluster related
+kube_config[:kube_config_location] = kube_config[:kube_config_location] ||= nil
+kube_config[:kubernetes_url] = kube_config[:kubernetes_url] ||= nil
+kube_config[:api_endpoint] = kube_config[:api_endpoint] ||= 'api'
+kube_config[:api_version] = kube_config[:api_version] ||= 'v1'
+kube_config[:client_cert] = kube_config[:client_cert] ||= nil
+kube_config[:client_key] = kube_config[:client_key] ||= nil
+kube_config[:ca_file] = kube_config[:ca_file] ||= nil
+kube_config[:verify_ssl] = kube_config[:verify_ssl] ||= false
+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
+
+# 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
+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
+
+Util::Logging::LogConfigs.new(app_config[:log_format], app_config[:log_level])
+
+logger.info('Initiating Kubernetes Discovery.')
+
+begin
+  # Initializing required clients.
+  OciLogAnalyticsResourcesDiscovery.initialize(
+    cluster_config_hash: cluster_config,
+    auth_config_hash: auth_config,
+    kube_config_hash: kube_config,
+    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
+rescue StandardError => e
+  unless e.backtrace.empty?
+    stack_trace = "\n"
+    e.backtrace.each { |line| stack_trace += "#{line}\n" }
+    logger.error("Stack trace - #{stack_trace.rstrip}")
+  end
+  logger.error('Kubernetes discovery failed.')
+  exit(1)
+end
+
+logger.info('Kubernetes discovery is successfully completed.')
+exit(0)

data/bin/setup

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+## 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/
+
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/config/oci_client_retry_config.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/
+
+require_relative '../util/logging'
+
+module Config
+  module OCIClientRetryConfig
+    extend Util::Logging
+
+    module_function
+
+    attr_accessor :retry_config
+
+    def set_default_retry_config
+      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,
+        sleep_calc_millis_proc: OCI::Retry::Functions::Sleep.exponential_backoff_with_full_jitter,
+        max_attempts: 5,
+        max_elapsed_time_millis: 300_000, # 5 minutes
+        max_sleep_between_attempts_millis: 10_000
+      )
+    end
+
+    def set_custom_retry_config(custom_retry_config)
+      @retry_config = custom_retry_config
+    end
+
+    def get_retry_config
+      @retry_config.nil? ? set_default_retry_config : @retry_config
+    end
+  end
+end

data/lib/discover/infrastructure.rb

@@ -0,0 +1,122 @@
+## 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'
+
+# Util
+require_relative '../util/oci_clients'
+
+module Discover
+  module Infrastructure
+    extend Util::Logging
+    extend Util::OCIClients
+
+    module_function
+
+    def fetch_cluster_details(_auth_object, cluster_id)
+      client = nil
+      begin
+        client = Util::OCIClients.get_clients[:ce_client]
+        response = client.get_cluster(cluster_id)
+
+        @cluster_details = response.data
+      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 }
+      begin
+        client = Util::OCIClients.get_clients[:ce_client]
+        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)
+      client = nil
+      opts = { compartment_id_in_subtree: true, access_level: 'ANY' }
+      begin
+        client = Util::OCIClients.get_clients[:id_client]
+        response = client.list_compartments(compartment_id, opts)
+
+        @id_response = response.data
+      rescue StandardError => e
+        logger.error("Error while fetching load balancer details: #{e}")
+        raise StandardError, 'Error while fetching load balancer details.'
+      end
+      @id_response
+    end
+
+    def fetch_load_balancer_details(_auth_object, 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
+      rescue StandardError => e
+        logger.error("Error while fetching load balancer details: #{e}")
+        raise StandardError, 'Error while fetching load balancer details.'
+      end
+      @lb_response
+    end
+
+    def fetch_free_text_details(_auth_object, cluster_id)
+      client = nil
+      begin
+        client = Util::OCIClients.get_clients[:rs_client]
+        response = client.search_resources(
+          OCI::ResourceSearch::Models::FreeTextSearchDetails.new(
+            type: 'FreeText',
+            text: cluster_id,
+            matchingContextType: 'HIGHLIGHTS'
+          )
+        )
+        @free_text_response = response.data
+      rescue StandardError => e
+        logger.error("Error while fetching free text details: #{e}")
+        raise StandardError, 'Error while fetching free text details.'
+      end
+      @free_text_response
+    end
+
+    def fetch_vcn_response(_auth_object, vcn_id)
+      client = nil
+      begin
+        client = Util::OCIClients.get_clients[:vnc_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.'
+      end
+      @vnc_response
+    end
+
+    def fetch_subnet_list_response(_auth_object, compartment_id, vcn_id)
+      client = nil
+      begin
+        opts = { vcn_id: vcn_id }
+        client = Util::OCIClients.get_clients[:vnc_client]
+        response = client.list_subnets(compartment_id, opts)
+
+        @subnet_response = response.data
+      rescue StandardError => e
+        logger.error("Error while discovering subnet details: #{e}")
+        raise StandardError, 'Error while discovering subnet details.'
+      end
+      @subnet_response
+    end
+  end
+end