aws-sdk-core 2.11.336 → 3.62.0

data/lib/aws-sdk-core/plugins/client_metrics_send_plugin.rb

@@ -0,0 +1,84 @@
+require 'date'
+
+module Aws
+  module Plugins
+    class ClientMetricsSendPlugin < Seahorse::Client::Plugin
+
+      def add_handlers(handlers, config)
+        if config.client_side_monitoring && config.client_side_monitoring_port
+          # AttemptHandler comes just before we would retry an error.
+          # Or before we would follow redirects.
+          handlers.add(AttemptHandler, step: :sign, priority: 39)
+          # LatencyHandler is as close to sending as possible.
+          handlers.add(LatencyHandler, step: :sign, priority: 0)
+        end
+      end
+
+      class LatencyHandler < Seahorse::Client::Handler
+        def call(context)
+          start_time = Aws::Util.monotonic_milliseconds
+          resp = @handler.call(context)
+          end_time = Aws::Util.monotonic_milliseconds
+          latency = end_time - start_time
+          context.metadata[:current_call_attempt].request_latency = latency
+          resp
+        end
+      end
+
+      class AttemptHandler < Seahorse::Client::Handler
+        def call(context)
+          request_metrics = context.metadata[:client_metrics]
+          attempt_opts = {
+            timestamp: DateTime.now.strftime('%Q').to_i,
+            fqdn: context.http_request.endpoint.host,
+            region: context.config.region,
+            user_agent: context.http_request.headers["user-agent"],
+          }
+          # It will generally cause an error, but it is semantically valid for
+          # credentials to not exist.
+          if context.config.credentials
+            attempt_opts[:access_key] =
+              context.config.credentials.credentials.access_key_id
+            attempt_opts[:session_token] =
+              context.config.credentials.credentials.session_token
+          end
+          call_attempt = request_metrics.build_call_attempt(attempt_opts)
+          context.metadata[:current_call_attempt] = call_attempt
+
+          resp = @handler.call(context)
+          if context.metadata[:redirect_region]
+            call_attempt.region = context.metadata[:redirect_region]
+          end
+          headers = context.http_response.headers
+          if headers.include?("x-amz-id-2")
+            call_attempt.x_amz_id_2 = headers["x-amz-id-2"]
+          end
+          if headers.include?("x-amz-request-id")
+            call_attempt.x_amz_request_id = headers["x-amz-request-id"]
+          end
+          if headers.include?("x-amzn-request-id")
+            call_attempt.x_amzn_request_id = headers["x-amzn-request-id"]
+          end
+          call_attempt.http_status_code = context.http_response.status_code
+          if e = resp.error
+            e_name = _extract_error_name(e)
+            e_msg = e.message
+            call_attempt.aws_exception = "#{e_name}"
+            call_attempt.aws_exception_msg = "#{e_msg}"
+          end
+          request_metrics.add_call_attempt(call_attempt)
+          resp
+        end
+
+        private
+        def _extract_error_name(error)
+          if error.is_a?(Aws::Errors::ServiceError)
+            error.class.code
+          else
+            error.class.name.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/credentials_configuration.rb

@@ -0,0 +1,62 @@
+module Aws
+  # @api private
+  module Plugins
+    # @api private
+    class CredentialsConfiguration < Seahorse::Client::Plugin
+
+      option(:access_key_id, doc_type: String, docstring: '')
+
+      option(:secret_access_key, doc_type: String, docstring: '')
+
+      option(:session_token, doc_type: String, docstring: '')
+
+      option(:profile,
+        doc_default: 'default',
+        doc_type: String,
+        docstring: <<-DOCS)
+Used when loading credentials from the shared credentials file
+at HOME/.aws/credentials.  When not specified, 'default' is used.
+        DOCS
+
+      option(:credentials,
+        required: true,
+        doc_type: 'Aws::CredentialProvider',
+        docstring: <<-DOCS
+Your AWS credentials. This can be an instance of any one of the
+following classes:
+
+* `Aws::Credentials` - Used for configuring static, non-refreshing
+  credentials.
+
+* `Aws::InstanceProfileCredentials` - Used for loading credentials
+  from an EC2 IMDS on an EC2 instance.
+
+* `Aws::SharedCredentials` - Used for loading credentials from a
+  shared file, such as `~/.aws/config`.
+
+* `Aws::AssumeRoleCredentials` - Used when you need to assume a role.
+
+When `:credentials` are not configured directly, the following
+locations will be searched for credentials:
+
+* `Aws.config[:credentials]`
+* The `:access_key_id`, `:secret_access_key`, and `:session_token` options.
+* ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
+* `~/.aws/credentials`
+* `~/.aws/config`
+* EC2 IMDS instance profile - When used by default, the timeouts are
+  very aggressive. Construct and pass an instance of
+  `Aws::InstanceProfileCredentails` to enable retries and extended
+  timeouts.
+        DOCS
+      ) do |config|
+        CredentialProviderChain.new(config).resolve
+      end
+
+      option(:instance_profile_credentials_retries, 0)
+
+      option(:instance_profile_credentials_timeout, 1)
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/endpoint_discovery.rb

@@ -1,39 +1,43 @@
 module Aws
   module Plugins
-
-    # Enables Endpoint Discovery per service when supported
-    #
-    # @seahorse.client.option [Boolean] :endpoint_discovery When
-    #     set to `true`, endpoint discovery will be enabled for
-    #     operations when available. Defaults to `false`.
-    #
-    # @seahorse.client.option [Integer] :endpoint_cache_max_entries
-    #   Used for the maximum size limit of the LRU cache storing endpoints data
-    #   for endpoint discovery enabled operations. Defaults to 1000.
-    #
-    # @seahorse.client.option [Integer] :endpoint_cache_max_threads
-    #   Used for the maximum threads in use for polling endpoints to be cached,
-    #   defaults to 10.
-    #
-    # @seahorse.client.option [Integer] :endpoint_cache_poll_interval
-    #   When :endpoint_discovery and :active_endpoint_cache is enabled,
-    #   Use this option to config the time interval in seconds for making
-    #   requests fetching endpoints information. Defaults to 60 sec.
-    #
-    # @seahorse.client.option [Boolean] :active_endpoint_cache
-    #   When set to `true`, a thread polling for endpoints will be running in
-    #   the background every 60 secs (default). Defaults to `false`.
+    # @api private
     class EndpointDiscovery < Seahorse::Client::Plugin
 
-      option(:endpoint_discovery, false) do |cfg|
+      option(:endpoint_discovery,
+        default: false,
+        doc_type: 'Boolean',
+        docstring: <<-DOCS) do |cfg|
+When set to `true`, endpoint discovery will be enabled for operations when available. Defaults to `false`.
+        DOCS
         resolve_endpoint_discovery(cfg)
       end
 
-      option(:endpoint_cache_max_entries, 1000)
-
-      option(:endpoint_cache_max_threads, 10)
-
-      option(:endpoint_cache_poll_interval, 60)
+      option(:endpoint_cache_max_entries,
+        default: 1000,
+        doc_type: Integer,
+        docstring: <<-DOCS
+Used for the maximum size limit of the LRU cache storing endpoints data
+for endpoint discovery enabled operations. Defaults to 1000.
+        DOCS
+      )
+
+      option(:endpoint_cache_max_threads,
+        default: 10,
+        doc_type: Integer,
+        docstring: <<-DOCS
+Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.
+        DOCS
+      )
+
+      option(:endpoint_cache_poll_interval,
+        default: 60,
+        doc_type: Integer,
+        docstring: <<-DOCS
+When :endpoint_discovery and :active_endpoint_cache is enabled,
+Use this option to config the time interval in seconds for making
+requests fetching endpoints information. Defaults to 60 sec.
+        DOCS
+      )
 
       option(:endpoint_cache) do |cfg|
         Aws::EndpointCache.new(
@@ -42,7 +46,14 @@ module Aws
         )
       end
 
-      option(:active_endpoint_cache, false)
+      option(:active_endpoint_cache,
+        default: false,
+        doc_type: 'Boolean',
+        docstring: <<-DOCS
+When set to `true`, a thread polling for endpoints will be running in
+the background every 60 secs (default). Defaults to `false`.
+        DOCS
+      )
 
       def add_handlers(handlers, config)
         handlers.add(Handler, priority: 90) if config.regional_endpoint
@@ -57,7 +68,7 @@ module Aws
           elsif discovery_cfg = context.operation.endpoint_discovery
             endpoint = _discover_endpoint(
               context,
-              str_2_bool(discovery_cfg["required"])
+              Aws::Util.str_2_bool(discovery_cfg["required"])
             )
             context.http_request.endpoint = _valid_uri(endpoint.address) if endpoint
             if endpoint || context.config.endpoint_discovery
@@ -134,15 +145,6 @@ module Aws
           end
         end
 
-        def str_2_bool(str)
-          case str.to_s
-          when "true" then true
-          when "false" then false
-          else
-            nil
-          end
-        end
-
       end
 
       private
@@ -150,16 +152,7 @@ module Aws
       def self.resolve_endpoint_discovery(cfg)
         env = ENV['AWS_ENABLE_ENDPOINT_DISCOVERY']
         shared_cfg = Aws.shared_config.endpoint_discovery(profile: cfg.profile)
-        self.str_2_bool(env) || self.str_2_bool(shared_cfg)
-      end
-
-      def self.str_2_bool(str)
-        case str.to_s
-        when "true" then true
-        when "false" then false
-        else
-          nil
-        end
+        Aws::Util.str_2_bool(env) || Aws::Util.str_2_bool(shared_cfg)
       end
 
     end

data/lib/aws-sdk-core/plugins/endpoint_pattern.rb

@@ -1,15 +1,16 @@
 module Aws
   module Plugins
-
-    # Disable host prefix per operation when available
-    #
-    # @seahorse.client.option [Boolean] :disable_host_prefix_injection
-    #   Set to true to disable SDK automatically adding host prefix
-    #   to default service endpoint when available.
-    #
+    # @api private
     class EndpointPattern < Seahorse::Client::Plugin
 
-      option(:disable_host_prefix_injection, false)
+      option(:disable_host_prefix_injection,
+        default: false,
+        doc_type: 'Boolean',
+        docstring: <<-DOCS
+Set to true to disable SDK automatically adding host prefix
+to default service endpoint when available.
+        DOCS
+      )
 
       def add_handlers(handlers, config)
         if config.regional_endpoint && !config.disable_host_prefix_injection

data/lib/aws-sdk-core/plugins/event_stream_configuration.rb

@@ -0,0 +1,30 @@
+module Aws
+  module Plugins
+
+    class EventStreamConfiguration < Seahorse::Client::Plugin
+      
+      option(:event_stream_handler,
+        default: nil,
+        doc_type: 'Proc',
+        docstring: <<-DOCS)
+When an EventStream or Proc object is provided, it will be used as callback for each chunk of event stream response received along the way.
+      DOCS
+
+      option(:input_event_stream_handler,
+        default: nil,
+        doc_type: 'Proc',
+        docstring: <<-DOCS)
+When an EventStream or Proc object is provided, it can be used for sending events for the event stream.
+      DOCS
+
+      option(:output_event_stream_handler,
+        default: nil,
+        doc_type: 'Proc',
+        docstring: <<-DOCS)
+When an EventStream or Proc object is provided, it will be used as callback for each chunk of event stream response received along the way.
+      DOCS
+
+    end
+
+  end
+end

data/lib/aws-sdk-core/plugins/global_configuration.rb

@@ -31,17 +31,17 @@ module Aws
     #     Aws::EC2.new
     #     #=> raises ArgumentError: invalid configuration option `:force_path_style'
     #
-    # To avoid this issue, you can nest service specific options 
+    # To avoid this issue, you can nest service specific options
     #
     #     Aws.config[:s3] = { force_path_style: true }
     #
     #     Aws::EC2.new # no error this time
     #     Aws::S3.new.config.force_path_style #=> true
     #
+    # @api private
     class GlobalConfiguration < Seahorse::Client::Plugin
 
-      # @api private
-      IDENTIFIERS = Set.new(SERVICE_MODULE_NAMES.map(&:downcase).map(&:to_sym))
+      @identifiers = Set.new()
 
       # @api private
       def before_initialize(client_class, options)
@@ -62,18 +62,27 @@ module Aws
 
       def apply_aws_defaults(client_class, options)
         Aws.config.each do |option_name, default|
-          next if IDENTIFIERS.include?(option_name)
+          next if self.class.identifiers.include?(option_name)
           next if options.key?(option_name)
           options[option_name] = default
         end
       end
 
-    end
-  end
+      class << self
 
-  service_added do |name, _, _|
-    Plugins::GlobalConfiguration::IDENTIFIERS << name.downcase.to_sym
-  end
+        # Registers an additional service identifier.
+        # @api private
+        def add_identifier(identifier)
+          @identifiers << identifier
+        end
 
-end
+        # @return [Set<String>]
+        # @api private
+        def identifiers
+          @identifiers
+        end
 
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/idempotency_token.rb

@@ -6,13 +6,12 @@ module Aws
     # Provides support for auto filling operation parameters
     # that enabled with `idempotencyToken` trait  with random UUID v4
     # when no value is provided
+    # @api private
     class IdempotencyToken < Seahorse::Client::Plugin
 
       # @api private
       class Handler < Seahorse::Client::Handler
 
-        # @param [RequestContext] context
-        # @param [Response]
         def call(context)
           auto_fill(context.params, context.operation.input)
           @handler.call(context)

data/lib/aws-sdk-core/plugins/invocation_id.rb

@@ -0,0 +1,33 @@
+require 'securerandom'
+
+module Aws
+  module Plugins
+
+    # @api private
+    class InvocationId < Seahorse::Client::Plugin
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          apply_invocation_id(context)
+          @handler.call(context)
+        end
+
+        private
+
+        def apply_invocation_id(context)
+          context.http_request.headers['amz-sdk-invocation-id'] = SecureRandom.uuid
+          if context[:input_event_emitter]
+            # only used for eventstreaming at input
+            context.http_request.headers['x-amz-content-sha256'] = 'STREAMING-AWS4-HMAC-SHA256-EVENTS'
+          end
+        end
+
+      end
+
+      handler(Handler, step: :initialize)
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/logging.rb

@@ -1,28 +1,28 @@
 module Aws
   module Plugins
-
-    # Enables logging for all requests.  This plugin allows you to configure
-    # your logging device, the log format and the level to log messages at.
-    #
     # @see Log::Formatter
-    #
-    # @seahorse.client.option [Logger] :logger (nil) The Logger instance
-    #   to send log messages to.  If this option is not set, logging
-    #   will be disabled.
-    #
-    # @seahorse.client.option [Symbol] :log_level (:info) The log level
-    #   to send messages to the logger at.
-    #
-    # @seahorse.client.option [Logging::LogFormatter] :log_formatter The log
-    #   formatter.  Defaults to {Seahorse::Client::Logging::Formatter.default}.
-    #
+    # @api private
     class Logging < Seahorse::Client::Plugin
 
-      option(:logger)
+      option(:logger,
+        doc_type: 'Logger',
+        docstring: <<-DOCS
+The Logger instance to send log messages to.  If this option
+is not set, logging will be disabled.
+        DOCS
+      )
 
-      option(:log_level, :info)
+      option(:log_level,
+        default: :info,
+        doc_type: Symbol,
+        docstring: 'The log level to send messages to the `:logger` at.'
+      )
 
-      option(:log_formatter) do |config|
+      option(:log_formatter,
+        doc_type: 'Aws::Log::Formatter',
+        doc_default: literal('Aws::Log::Formatter.default'),
+        docstring: 'The log formatter.'
+      ) do |config|
         Log::Formatter.default if config.logger
       end