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

data/lib/util/log_analytics.rb

@@ -33,7 +33,7 @@ module Util
                                                 upload_discovery_data_details = payload,
                                                 opts)
       rescue StandardError => e
-        logger.error("Error while uploading payload to 'Log Analytics': #{e}")
+        logger.error("Error while uploading payload to 'Log Analytics'. Error: #{e}")
         raise StandardError, "Unable to upload data to 'Log Analytics' client."
       end
       response
@@ -56,7 +56,7 @@ module Util
         region = signer.region
       else
         logger.warn("Unknown auth_type provided for Discovery API (raw request): #{auth_object[:auth_type]}")
-        raise StandardError 'Unknown auth_type for Discovery API (raw request)'
+        raise StandardError, 'Unknown auth_type for Discovery API (raw request)'
       end
 
       # Construct URL protocol, subdomain, domain and port

data/lib/util/oci_clients.rb

@@ -15,10 +15,10 @@ module Util
 
     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
+                  :auth_type, :auth_config_object, :oci_domain, :oci_retry_config, :oci_region
 
     # This must be the first method called before any other method
-    def initialize(auth_config_hash, options)
+    def initialize(auth_config_hash)
       begin
         initialize_auth_config(auth_config_hash)
       rescue StandardError => e
@@ -28,7 +28,7 @@ module Util
       logger.debug('Successfully loaded the OCI auth config.')
 
       begin
-        create_clients(options)
+        create_clients
       rescue StandardError => e
         logger.error("Error occurred in creating OCI clients - #{e}")
         raise e
@@ -38,27 +38,86 @@ module Util
       set_clients
     end
 
-    def create_clients(options)
+    def initialize_auth_config(auth_config_hash)
+      @auth_type = auth_config_hash[:auth_type]
+      @oci_domain = auth_config_hash[:oci_domain]
+      @la_endpoint = auth_config_hash[:endpoint]
+
       begin
-        @la_client = initialize_la_client(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
+            federation_endpoint = "https://auth.#{@oci_domain}/v1/x509"
+            logger.info("Federation Endpoint: #{federation_endpoint}")
+            @instance_principals_signer = OCI::Auth::Signers::InstancePrincipalsSecurityTokenSigner.new(
+              federation_endpoint: federation_endpoint
+            )
+          end
+          @oci_region = @instance_principals_signer.region
+        # 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])
+          @oci_region = @oci_config.region
+        else
+          raise Exception::InvalidOption, "#{@auth_type}"
+        end
+      rescue StandardError => e
+        logger.error("Error occurred while initializing OCI authentication configuration. Error: #{e}")
+        raise e
+      end
+      set_auth_config_object
+    end
+
+    def set_clients
+      @oci_clients = {
+        ce_client: @ce_client,
+        id_client: @id_client,
+        lb_client: @lb_client,
+        la_client: @la_client,
+        rqs_client: @rqs_client,
+        vcn_client: @vcn_client,
+        rms_client: @rms_client
+      }
+    end
+
+    def get_clients
+      @oci_clients
+    end
+
+    def get_region
+      @oci_region
+    end
 
-        return if options[:mode] == 'object'
+    def get_domain
+      @oci_domain
+    end
 
+    def create_clients()
+      begin
+        @oci_retry_config = Config::OCIClientRetryConfig.custom_retry_policy
+
+        @la_client = initialize_la_client
         @ce_client = initialize_ce_client
         @id_client = initialize_id_client
         @lb_client = initialize_lb_client
-        @rs_client = initialize_rs_client
+        @rqs_client = initialize_rqs_client
         @vcn_client = initialize_vcn_client
-
+        @rms_client = initialize_rms_client
       rescue StandardError => e
         logger.error("Error while creating OCI clients. Error: #{e}")
         raise e
       end
+      logger.info('OCI clients created.')
     end
 
     def initialize_ce_client()
       client = nil
       endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
       unless @oci_domain.nil?
         endpoint = "https://containerengine.#{@oci_domain}"
         logger.info("CE Client endpoint: #{endpoint}")
@@ -67,13 +126,16 @@ module Util
       begin
         case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::ContainerEngine::ContainerEngineClient.new(config: @oci_config, endpoint: endpoint)
+          client = OCI::ContainerEngine::ContainerEngineClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
         when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
-          client = OCI::ContainerEngine::ContainerEngineClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
+          client = OCI::ContainerEngine::ContainerEngineClient.new(
+                config: @oci_config, endpoint: endpoint,
+                signer: @instance_principals_signer,
+                retry_config: retry_config)
         else
           logger.warn("Unknown auth_type '#{@auth_type}' provided for container engine client.")
         end
-        logger.info("CE Client created.")
+        logger.debug('CE Client created.')
         @ce_client = client
       rescue StandardError => e
         logger.error("Error while creating container engine client: #{e}")
@@ -85,6 +147,7 @@ module Util
     def initialize_id_client()
       client = nil
       endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
       unless @oci_domain.nil?
         endpoint = "https://identity.#{@oci_domain}"
         logger.info("ID Client endpoint: #{endpoint}")
@@ -93,13 +156,13 @@ module Util
       begin
         case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::Identity::IdentityClient.new(config: @oci_config, endpoint: endpoint)
-        when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::Identity::IdentityClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
+          client = OCI::Identity::IdentityClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::Identity::IdentityClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer, retry_config: retry_config)
         else
           logger.warn("Unknown auth_type '#{@auth_type}' provided for identity client.")
         end
-        logger.info("ID Client created.")
+        logger.debug('ID Client created.')
         @id_client = client
       rescue StandardError => e
         logger.error("Error while creating identity client: #{e}")
@@ -111,6 +174,7 @@ module Util
     def initialize_lb_client()
       client = nil
       endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
       unless @oci_domain.nil?
         endpoint = "https://iaas.#{@oci_domain}"
         logger.info("LB Client endpoint: #{endpoint}")
@@ -119,13 +183,13 @@ module Util
       begin
         case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::LoadBalancer::LoadBalancerClient.new(config: @oci_config, endpoint: endpoint)
-        when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::LoadBalancer::LoadBalancerClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
+          client = OCI::LoadBalancer::LoadBalancerClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::LoadBalancer::LoadBalancerClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer, retry_config: retry_config)
         else
           logger.warn("Unknown auth_type '#{@auth_type}' provided for load balancer client.")
         end
-        logger.info("LB Client created.")
+        logger.debug('LB Client created.')
         @lb_client = client
       rescue StandardError => e
         logger.error("Error while creating load balancer client: #{e}")
@@ -134,10 +198,11 @@ module Util
       @lb_client
     end
 
-    def initialize_la_client(custom_retry_config)
-      logger.debug("Creating log analytics client with auth_type: #{@auth_type}")
+    def initialize_la_client()
+      client = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
 
-      Config::OCIClientRetryConfig.set_custom_retry_config(custom_retry_config) unless custom_retry_config.nil?
+      logger.debug("Creating log analytics client with auth_type: #{@auth_type}")
 
       endpoint = @la_endpoint
       if endpoint.nil? && !@oci_domain.nil?
@@ -145,24 +210,22 @@ module Util
           logger.info("LA Client endpoint: #{endpoint}")
       end
 
-      client = nil
-
       begin
         case @auth_type
         when Enum::AuthTypeEnum::CONFIG
           client = OCI::LogAnalytics::LogAnalyticsClient.new(config: @oci_config,
                                                              endpoint: endpoint,
-                                                             retry_config: Config::OCIClientRetryConfig.get_retry_config)
+                                                             retry_config: retry_config)
         when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
           client = OCI::LogAnalytics::LogAnalyticsClient.new(config: @oci_config,
                                                              endpoint: endpoint,
                                                              signer: @instance_principals_signer,
-                                                             retry_config: Config::OCIClientRetryConfig.get_retry_config)
+                                                             retry_config: retry_config)
         else
           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.")
+        logger.debug('LA Client created.')
         @la_client = client
       rescue StandardError => e
         logger.error("Error while creating log analytics client: #{e}")
@@ -171,50 +234,60 @@ module Util
       @la_client
     end
 
-    def initialize_rs_client()
+    def initialize_rqs_client()
       client = nil
       endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
+
       unless @oci_domain.nil?
         endpoint = "https://query.#{@oci_domain}"
-        logger.info("RS Client endpoint: #{endpoint}")
+        logger.info("RQS Client endpoint: #{endpoint}")
       end
+
       logger.debug("Creating resource search client with auth_type: #{@auth_type}")
+
       begin
         case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::ResourceSearch::ResourceSearchClient.new(config: @oci_config, endpoint: endpoint)
-        when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::ResourceSearch::ResourceSearchClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
+          client = OCI::ResourceSearch::ResourceSearchClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::ResourceSearch::ResourceSearchClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer, retry_config: retry_config)
         else
           logger.warn("Unknown auth_type '#{@auth_type}' provided for resource search client.")
         end
-        logger.info("RS Client created.")
-        @rs_client = client
+        logger.debug('RQS Client created.')
+        @rqs_client = client
       rescue StandardError => e
         logger.error("Error while creating resource search client: #{e}")
         raise e
       end
-      @rs_client
+      @rqs_client
     end
 
     def initialize_vcn_client()
       client = nil
       endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
+
       unless @oci_domain.nil?
-        endpoint = "https://iass.#{@oci_domain}"
+        # NOTE: Dec 3rd, 2024
+        # VCN endpoint does not support region.oci.domain template hence converting to region.domain template
+        endpoint = "https://iaas.#{@oci_domain.gsub('.oci', '')}"
         logger.info("VCN Client endpoint: #{endpoint}")
       end
+
       logger.debug("Creating virtual network client with auth_type: #{@auth_type}")
+
       begin
         case @auth_type
         when Enum::AuthTypeEnum::CONFIG
-          client = OCI::Core::VirtualNetworkClient.new(config: @oci_config, endpoint: endpoint)
-        when Enum::AuthTypeEnum::PRINCIPAL
-          client = OCI::Core::VirtualNetworkClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer)
+          client = OCI::Core::VirtualNetworkClient.new(config: @oci_config, endpoint: endpoint, retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::Core::VirtualNetworkClient.new(config: @oci_config, endpoint: endpoint, signer: @instance_principals_signer, retry_config: retry_config)
         else
           logger.warn("Unknown auth_type '#{@auth_type}' provided for virtual network client.")
         end
-        logger.info("VCN Client created.")
+        logger.debug('VCN Client created.')
         @vcn_client = client
       rescue StandardError => e
         logger.error("Error while creating virtual network client: #{e}")
@@ -223,51 +296,37 @@ module Util
       @vcn_client
     end
 
-    def initialize_auth_config(auth_config_hash)
-      @auth_type = auth_config_hash[:auth_type]
-      @oci_domain = auth_config_hash[:oci_domain]
-      @la_endpoint = auth_config_hash[:endpoint]
+    def initialize_rms_client()
+      client = nil
+      endpoint = nil
+      retry_config = Config::OCIClientRetryConfig.oci_default_retry_config if @oci_retry_config.nil?
+
+      unless @oci_domain.nil?
+        endpoint = "https://resourcemanager.#{@oci_domain}"
+        logger.info("VCN Client endpoint: #{endpoint}")
+      end
 
       begin
-        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])
+        case @auth_type
+        when Enum::AuthTypeEnum::CONFIG
+          client = OCI::ResourceManager::ResourceManagerClient.new(config: @oci_config,
+                                                                   endpoint: endpoint,
+                                                                   retry_config: retry_config)
+        when Enum::AuthTypeEnum::INSTANCE_PRINCIPAL
+          client = OCI::ResourceManager::ResourceManagerClient.new(config: @oci_config,
+                                                                   endpoint: endpoint,
+                                                                   signer: @instance_principals_signer,
+                                                                   retry_config: retry_config)
         else
-          raise Exception::InvalidOption, "#{@auth_type}"
+          logger.warn("Unknown auth_type '#{auth_object[:auth_type]}' provided for resource manager client.")
         end
+        logger.debug('RMS Client created.')
+        @rms_client = client
       rescue StandardError => e
-        logger.error("Error occurred while initializing OCI authentication configuration. Error: #{e}")
+        logger.error("Error while creating resource manager client: #{e}")
         raise e
       end
-      set_auth_config_object
-    end
-
-    def get_clients
-      @oci_clients
-    end
-
-    def set_clients
-      @oci_clients = {
-        ce_client: @ce_client,
-        id_client: @id_client,
-        lb_client: @lb_client,
-        la_client: @la_client,
-        rs_client: @rs_client,
-        vcn_client: @vcn_client
-      }
+      @rms_client
     end
 
     def get_auth_config_object