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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e467bfdc3f4460d05f1eacd501b160ef847014e9fe213511a43efbb019406fca
-  data.tar.gz: 4e3d61c0fcf9fd754934814599f873d995f94b4385f04058fd1781836be8f8ac
+  metadata.gz: 1460fe2976e56c6f9ff763614d151ff90b96d2edd5662c135592a34885f2f512
+  data.tar.gz: 11e3c57a184df35f61ff7b61829a6ce9a78f818a8c2373a930052d7a311e00e8
 SHA512:
-  metadata.gz: c6de2c60fc3b81c618588bcfb7d0fdf4913fed6584d22cffc68c94898f5733bd9d7278c21c9caa5079e687e87f23904bc2b24dfa1d145c21e75099e513e4afd5
-  data.tar.gz: 2ca3d0bd22bd41febf9eeec22ac58c6e78fb875267e3400f83aea7cc65d7f34a932c4d8e33a14da5db7c689d402c1d53beb078b49312446908b1bcd56165dadc
+  metadata.gz: 3a2babc9026d6ed886ab3f0527dad557ff43796737a517c04aac2485f04a32b00b3918f445a736f2123a0740f43ab15dbf12ae2c96c939e7394d2a1bb45522a1
+  data.tar.gz: 9f4bed331119bca930922675bcf156e1825afafce7d6f53215f2fb2bb81dffce15d27071efbc771e8200252d96bf570592e139308916de8993f667cfa9434d4d

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

@@ -8,6 +8,7 @@ require 'optparse'
 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
@@ -34,11 +35,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 }
@@ -96,6 +103,17 @@ begin
     end
   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
+
+    if auth_config[:auth_type] == Enum::AuthTypeEnum::CONFIG
+      raise OptionParser::MissingArgument, '--config_file_location'  if auth_config[:config_file_location].nil?
+    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'
@@ -116,11 +134,23 @@ cluster_config[:kubernetes_cluster_id] = cluster_config[:kubernetes_cluster_id]
 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

data/lib/discover/infrastructure.rb

@@ -93,7 +93,7 @@ module Discover
     def fetch_vcn_response(_auth_object, vcn_id)
       client = nil
       begin
-        client = Util::OCIClients.get_clients[:vnc_client]
+        client = Util::OCIClients.get_clients[:vcn_client]
         response = client.get_vcn(vcn_id)
 
         @vnc_response = response.data
@@ -108,7 +108,7 @@ module Discover
       client = nil
       begin
         opts = { vcn_id: vcn_id }
-        client = Util::OCIClients.get_clients[:vnc_client]
+        client = Util::OCIClients.get_clients[:vcn_client]
         response = client.list_subnets(compartment_id, opts)
 
         @subnet_response = response.data

data/lib/enum/auth_type_enum.rb

@@ -5,5 +5,6 @@ module Enum
   module AuthTypeEnum
     CONFIG = 'config'.freeze
     INSTANCE_PRINCIPAL = 'instance_principal'.freeze
+    # OKE_WORKLOAD_IDENTITY = 'oke_workload_identity'.freeze
   end
 end

data/lib/oci_loganalytics_resources_discovery.rb

@@ -52,10 +52,11 @@ module OciLogAnalyticsResourcesDiscovery
 
     # OCI.logger = Util::Logging.logger
 
-    get_auth_object
-
     options = { mode: app_config_hash[:mode] }
-    get_oci_clients(options)
+    Util::OCIClients.initialize(@auth_config_hash, options)
+
+    @auth_object = Util::OCIClients.get_auth_config_object
+    @oci_clients = Util::OCIClients.get_clients
 
     if @app_config_hash[:mode] == 'object'
       @snapshot_id = Time.now.to_i
@@ -147,17 +148,6 @@ module OciLogAnalyticsResourcesDiscovery
     end
   end
 
-  def get_auth_object
-    begin
-      Util::OCIClients.initialize_auth_config(@auth_config_hash)
-    rescue StandardError => e
-      logger.error("Error occurred in creating authentication object - #{e}")
-      raise e
-    end
-    @auth_object = Util::OCIClients.get_auth_config_object
-    logger.debug('Successfully loaded the OCI auth config.')
-  end
-
   def get_kube_clients
     begin
       Util::KubeClient.create_clients(@kube_config_hash)
@@ -169,17 +159,6 @@ module OciLogAnalyticsResourcesDiscovery
     logger.debug('Kubeclients created successfully.')
   end
 
-  def get_oci_clients(options)
-    begin
-      Util::OCIClients.create_clients(@auth_object, options)
-    rescue StandardError => e
-      logger.error("Error occurred in creating OCI clients - #{e}")
-      raise e
-    end
-    @oci_clients = Util::OCIClients.get_clients
-    logger.debug('OCI clients created successfully.')
-  end
-
   def get_infra_resources_payload
     logger.debug('Discovering Infrastructure Resources')
     infra_resources_payload = nil

data/lib/util/helper.rb

@@ -0,0 +1,15 @@
+module Util
+  module Helper
+    module_function
+    # Function to check if a value is defined in the enum
+    def enum_value_defined?(enum_module, value)
+      enum_module.constants(false).any? { |const| enum_module.const_get(const) == value }
+    end
+
+    # Function to get enum values as list
+    def enum_values(enum_module)
+      enum_module.constants(false).map { |const| enum_module.const_get(const) }
+    end
+
+  end
+end

data/lib/util/oci_clients.rb

@@ -13,43 +13,67 @@ module Util
 
     module_function
 
-    attr_accessor :oci_clients, :ce_client, :id_client, :lb_client, :la_client, :rs_client, :vnc_client,
-                  :oci_config, :instance_principals_signer, :auth_type, :endpoint, :auth_config_object
+    attr_accessor :oci_clients, :ce_client, :id_client, :lb_client, :la_client, :rs_client,
+                  :vcn_client, :oci_config, :instance_principals_signer, :la_endpoint,
+                  :auth_type, :auth_config_object, :oci_domain
 
-    def create_clients(auth_object, options)
+    # This must be the first method called before any other method
+    def initialize(auth_config_hash, options)
       begin
-        @la_client = initialize_la_client(auth_object, nil)
+        initialize_auth_config(auth_config_hash)
+      rescue StandardError => e
+        logger.error("Error occurred in creating authentication object - #{e}")
+        raise e
+      end
+      logger.debug('Successfully loaded the OCI auth config.')
 
-        if options[:mode] == 'object'
-          set_clients
-          return
-        end
+      begin
+        create_clients(options)
+      rescue StandardError => e
+        logger.error("Error occurred in creating OCI clients - #{e}")
+        raise e
+      end
+      logger.debug('OCI clients created successfully.')
+
+      set_clients
+    end
+
+    def create_clients(options)
+      begin
+        @la_client = initialize_la_client(nil)
+
+        return if options[:mode] == 'object'
+
+        @ce_client = initialize_ce_client
+        @id_client = initialize_id_client
+        @lb_client = initialize_lb_client
+        @rs_client = initialize_rs_client
+        @vcn_client = initialize_vcn_client
 
-        @ce_client = initialize_ce_client(auth_object)
-        @id_client = initialize_id_client(auth_object)
-        @lb_client = initialize_lb_client(auth_object)
-        @rs_client = initialize_rs_client(auth_object)
-        @vnc_client = initialize_vnc_client(auth_object)
       rescue StandardError => e
         logger.error("Error while creating OCI clients. Error: #{e}")
         raise e
       end
-      set_clients
-      nil
     end
 
-    def initialize_ce_client(auth_object)
+    def initialize_ce_client()
       client = nil
-      logger.debug("Creating container engine client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      unless @oci_domain.nil?
+        endpoint = "https://containerengine.#{@oci_domain}"
+        logger.info("CE Client endpoint: #{endpoint}")
+      end
+      logger.debug("Creating container engine client with auth_type: #{@auth_type}")
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::ContainerEngine::ContainerEngineClient.new(config: auth_object[:oci_config])
+          client = OCI::ContainerEngine::ContainerEngineClient.new(config: @oci_config, endpoint: endpoint)
         when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
-          client = OCI::ContainerEngine::ContainerEngineClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::ContainerEngine::ContainerEngineClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for container engine client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for container engine client.")
         end
+        logger.info("CE Client created.")
         @ce_client = client
       rescue StandardError => e
         logger.error("Error while creating container engine client: #{e}")
@@ -58,20 +82,24 @@ module Util
       client
     end
 
-    def initialize_id_client(auth_object)
+    def initialize_id_client()
       client = nil
-      logger.debug("Creating identity client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      unless @oci_domain.nil?
+        endpoint = "https://identity.#{@oci_domain}"
+        logger.info("ID Client endpoint: #{endpoint}")
+      end
+      logger.debug("Creating identity client with auth_type: #{@auth_type}")
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::Identity::IdentityClient.new(config: auth_object[:oci_config])
-        when Enum::AuthTypeEnum::ENDPOINT
-          client = OCI::Identity::IdentityClient.new(config: auth_object[:oci_config], endpoint: auth_object[:endpoint])
+          client = OCI::Identity::IdentityClient.new(config: @oci_config, endpoint: endpoint)
         when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::Identity::IdentityClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::Identity::IdentityClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for identity client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for identity client.")
         end
+        logger.info("ID Client created.")
         @id_client = client
       rescue StandardError => e
         logger.error("Error while creating identity client: #{e}")
@@ -80,20 +108,24 @@ module Util
       @id_client
     end
 
-    def initialize_lb_client(auth_object)
+    def initialize_lb_client()
       client = nil
-      logger.debug("Creating load balancer client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      unless @oci_domain.nil?
+        endpoint = "https://iaas.#{@oci_domain}"
+        logger.info("LB Client endpoint: #{endpoint}")
+      end
+      logger.debug("Creating load balancer client with auth_type: #{@auth_type}")
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::LoadBalancer::LoadBalancerClient.new(config: auth_object[:oci_config])
-        when Enum::AuthTypeEnum::ENDPOINT
-          client = OCI::LoadBalancer::LoadBalancerClient.new(config: auth_object[:oci_config], endpoint: auth_object[:endpoint])
+          client = OCI::LoadBalancer::LoadBalancerClient.new(config: @oci_config, endpoint: endpoint)
         when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::LoadBalancer::LoadBalancerClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::LoadBalancer::LoadBalancerClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for load balancer client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for load balancer client.")
         end
+        logger.info("LB Client created.")
         @lb_client = client
       rescue StandardError => e
         logger.error("Error while creating load balancer client: #{e}")
@@ -102,26 +134,35 @@ module Util
       @lb_client
     end
 
-    def initialize_la_client(auth_object, custom_retry_config)
-      client = nil
-      logger.debug("Creating log analytics client with auth_type: #{auth_object[:auth_type]}")
+    def initialize_la_client(custom_retry_config)
+      logger.debug("Creating log analytics client with auth_type: #{@auth_type}")
+
       Config::OCIClientRetryConfig.set_custom_retry_config(custom_retry_config) unless custom_retry_config.nil?
 
+      endpoint = @la_endpoint
+      if endpoint.nil? && !@oci_domain.nil?
+          endpoint = "https://loganalytics.#{@oci_domain}"
+          logger.info("LA Client endpoint: #{endpoint}")
+      end
+
+      client = nil
+
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::LogAnalytics::LogAnalyticsClient.new(config: auth_object[:oci_config],
-                                                             endpoint: auth_object[:endpoint],
+          client = OCI::LogAnalytics::LogAnalyticsClient.new(config: @oci_config,
+                                                             endpoint: endpoint,
                                                              retry_config: Config::OCIClientRetryConfig.get_retry_config)
         when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
-          client = OCI::LogAnalytics::LogAnalyticsClient.new(config: auth_object[:oci_config],
-                                                             endpoint: auth_object[:endpoint],
-                                                             signer: auth_object[:instance_principals_signer],
+          client = OCI::LogAnalytics::LogAnalyticsClient.new(config: @oci_config,
+                                                             endpoint: endpoint,
+                                                             signer: @instance_principals_signer,
                                                              retry_config: Config::OCIClientRetryConfig.get_retry_config)
         else
-          logger.warn("Unknown auth_type while creating log analytics client: #{auth_object[:auth_type]}")
+          logger.warn("Unknown auth_type while creating log analytics client: #{@auth_type}")
           raise StandardError, 'Unknown auth_type for log analytics client.'
         end
+        logger.info("LA Client created.")
         @la_client = client
       rescue StandardError => e
         logger.error("Error while creating log analytics client: #{e}")
@@ -130,20 +171,24 @@ module Util
       @la_client
     end
 
-    def initialize_rs_client(auth_object)
+    def initialize_rs_client()
       client = nil
-      logger.debug("Creating resource search client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      unless @oci_domain.nil?
+        endpoint = "https://query.#{@oci_domain}"
+        logger.info("RS Client endpoint: #{endpoint}")
+      end
+      logger.debug("Creating resource search client with auth_type: #{@auth_type}")
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::ResourceSearch::ResourceSearchClient.new(config: auth_object[:oci_config])
-        when Enum::AuthTypeEnum::ENDPOINT
-          client = OCI::ResourceSearch::ResourceSearchClient.new(config: auth_object[:oci_config], endpoint: auth_object[:endpoint])
+          client = OCI::ResourceSearch::ResourceSearchClient.new(config: @oci_config, endpoint: endpoint)
         when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::ResourceSearch::ResourceSearchClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::ResourceSearch::ResourceSearchClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for resource search client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for resource search client.")
         end
+        logger.info("RS Client created.")
         @rs_client = client
       rescue StandardError => e
         logger.error("Error while creating resource search client: #{e}")
@@ -152,43 +197,56 @@ module Util
       @rs_client
     end
 
-    def initialize_vnc_client(auth_object)
+    def initialize_vcn_client()
       client = nil
-      logger.debug("Creating virtual network client with auth_type: #{auth_object[:auth_type]}")
+      endpoint = nil
+      unless @oci_domain.nil?
+        endpoint = "https://iass.#{@oci_domain}"
+        logger.info("VCN Client endpoint: #{endpoint}")
+      end
+      logger.debug("Creating virtual network client with auth_type: #{@auth_type}")
       begin
-        case auth_object[:auth_type]
+        case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::Core::VirtualNetworkClient.new(config: auth_object[:oci_config])
-        when Enum::AuthTypeEnum::ENDPOINT
-          client = OCI::Core::VirtualNetworkClient.new(config: auth_object[:oci_config], endpoint: auth_object[:endpoint])
+          client = OCI::Core::VirtualNetworkClient.new(config: @oci_config, endpoint: endpoint)
         when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::Core::VirtualNetworkClient.new(config: auth_object[:oci_config], signer: auth_object[:instance_principals_signer])
+          client = OCI::Core::VirtualNetworkClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
         else
-          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for virtual network client.")
+          logger.warn("Unknown auth_type '#{@auth_type}' provided for virtual network client.")
         end
-        @vnc_client = client
+        logger.info("VCN Client created.")
+        @vcn_client = client
       rescue StandardError => e
         logger.error("Error while creating virtual network client: #{e}")
         raise e
       end
-      @vnc_client
+      @vcn_client
     end
 
     def initialize_auth_config(auth_config_hash)
-      @endpoint = auth_config_hash[:endpoint]
+      @auth_type = auth_config_hash[:auth_type]
+      @oci_domain = auth_config_hash[:oci_domain]
+      @la_endpoint = auth_config_hash[:endpoint]
 
       begin
-        if !auth_config_hash[:config_file_location].nil? && !auth_config_hash[:profile_name].nil?
+        if @auth_type == Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          @oci_config = OCI::Config.new
+          if @oci_domain.nil?
+            @instance_principals_signer = OCI::Auth::Signers::InstancePrincipalsSecurityTokenSigner.new
+          else
+            fedration_endpoint = "https://auth.#{@oci_domain}/v1/x509"
+            logger.info("Federation Endpoint: #{fedration_endpoint}")
+            @instance_principals_signer = OCI::Auth::Signers::InstancePrincipalsSecurityTokenSigner.new(
+              federation_endpoint: fedration_endpoint
+            )
+          end
+        # elsif @auth_type == Enum::AuthTypeEnum::OKE_WORKLOAD_IDENTITY
+        #   @workload_identity_signer = OCI::Auth::Signers::oke_workload_resource_principal_signer
+        elsif @auth_type == Enum::AuthTypeEnum::CONFIG
           @oci_config = OCI::ConfigFileLoader.load_config(config_file_location: auth_config_hash[:config_file_location],
-                                                          profile_name: auth_config_hash[:profile_name])
-        end
-
-        if !@oci_config.nil?
-          @auth_type = Enum::AuthTypeEnum::CONFIG
+          profile_name: auth_config_hash[:profile_name])
         else
-          @oci_config = OCI::Config.new
-          @instance_principals_signer = instance_principals_signer = OCI::Auth::Signers::InstancePrincipalsSecurityTokenSigner.new
-          @auth_type = Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          raise Exception::InvalidOption, "#{@auth_type}"
         end
       rescue StandardError => e
         logger.error("Error occurred while initializing OCI authentication configuration. Error: #{e}")
@@ -208,7 +266,7 @@ module Util
         lb_client: @lb_client,
         la_client: @la_client,
         rs_client: @rs_client,
-        vnc_client: @vnc_client
+        vcn_client: @vcn_client
       }
     end
 
@@ -219,9 +277,11 @@ module Util
     def set_auth_config_object
       @auth_object = {
         oci_config: @oci_config,
-        endpoint: @endpoint,
+        la_endpoint: @la_endpoint,
         instance_principals_signer: @instance_principals_signer,
-        auth_type: @auth_type
+        # workload_identity_signer: @workload_identity_signer,
+        auth_type: @auth_type,
+        oci_domain: @oci_domain
       }.compact
     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.2'.freeze
+  VERSION = '1.0.3'.freeze
 end

data/oci-logging-analytics-kubernetes-discovery.gemspec

@@ -44,7 +44,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1.2', '>= 1.2.2'
   spec.add_runtime_dependency 'kubeclient', '~> 4.9', '>= 4.9.3'
-  spec.add_runtime_dependency 'oci', '~> 2.20'
+  spec.add_runtime_dependency 'oci', '~> 2.21'
   spec.add_runtime_dependency 'rubyzip', '~> 2.3.2'
   spec.add_runtime_dependency 'yajl-ruby', '~> 1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oci-logging-analytics-kubernetes-discovery
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Oracle
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-29 00:00:00.000000000 Z
+date: 2024-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -225,14 +225,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.20'
+        version: '2.21'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.20'
+        version: '2.21'
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -299,6 +299,7 @@ files:
 - lib/infra_resources.rb
 - lib/objects_resources.rb
 - lib/oci_loganalytics_resources_discovery.rb
+- lib/util/helper.rb
 - lib/util/kube_client.rb
 - lib/util/kubectl_ops.rb
 - lib/util/log_analytics.rb
@@ -327,7 +328,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.27
 signing_key:
 specification_version: 4
 summary: A rubygem for discovering Kubernetes resources and send it to OCI Logging