aws-sdk-core 3.181.0 → 3.209.1

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

@@ -8,6 +8,7 @@ module Aws
       option(:stub_responses,
         default: false,
         doc_type: 'Boolean',
+        rbs_type: 'untyped',
         docstring: <<-DOCS)
 Causes the client to return stubbed responses. By default
 fake responses are generated and returned. You can specify
@@ -48,6 +49,14 @@ requests are made, and retries are disabled.
       class Handler < Seahorse::Client::Handler
 
         def call(context)
+          span_wrapper(context) do
+            stub_responses(context)
+          end
+        end
+
+        private
+
+        def stub_responses(context)
           stub = context.client.next_stub(context)
           resp = Seahorse::Client::Response.new(context: context)
           async_mode = context.client.is_a? Seahorse::Client::AsyncBase
@@ -57,8 +66,15 @@ requests are made, and retries are disabled.
             apply_stub(stub, resp, async_mode)
           end
 
-          async_mode ? Seahorse::Client::AsyncResponse.new(
-            context: context, stream: context[:input_event_stream_handler].event_emitter.stream, sync_queue: Queue.new) : resp
+          if async_mode
+            Seahorse::Client::AsyncResponse.new(
+              context: context,
+              stream: context[:input_event_stream_handler].event_emitter.stream,
+              sync_queue: Queue.new
+            )
+          else
+            resp
+          end
         end
 
         def apply_stub(stub, response, async_mode = false)
@@ -98,6 +114,18 @@ requests are made, and retries are disabled.
           http_resp.signal_done
         end
 
+        def span_wrapper(context, &block)
+          context.tracer.in_span(
+            'Handler.StubResponses',
+            attributes: Aws::Telemetry.http_request_attrs(context)
+          ) do |span|
+            block.call.tap do
+              span.add_attributes(
+                Aws::Telemetry.http_response_attrs(context)
+              )
+            end
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+    # @api private
+    class Telemetry < Seahorse::Client::Plugin
+      option(
+        :telemetry_provider,
+        default: Aws::Telemetry::NoOpTelemetryProvider,
+        doc_type: Aws::Telemetry::TelemetryProviderBase,
+        rbs_type: Aws::Telemetry::TelemetryProviderBase,
+        docstring: <<-DOCS) do |_cfg|
+Allows you to provide a telemetry provider, which is used to 
+emit telemetry data. By default, uses `NoOpTelemetryProvider` which 
+will not record or emit any telemetry data. The SDK supports the 
+following telemetry providers:
+
+* OpenTelemetry (OTel) - To use the OTel provider, install and require the 
+`opentelemetry-sdk` gem and then, pass in an instance of a 
+`Aws::Telemetry::OTelProvider` for telemetry provider.
+        DOCS
+        Aws::Telemetry::NoOpTelemetryProvider.new
+      end
+
+      def after_initialize(client)
+        validate_telemetry_provider(client.config)
+      end
+
+      def validate_telemetry_provider(config)
+        unless config.telemetry_provider.is_a?(Aws::Telemetry::TelemetryProviderBase)
+          raise ArgumentError,
+                'Must provide a telemetry provider for the '\
+                '`telemetry_provider` configuration option.'
+        end
+      end
+
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          span_wrapper(context) { @handler.call(context) }
+        end
+
+        private
+
+        def span_wrapper(context, &block)
+          service_id = service_id(context)
+          attributes = {
+            'rpc.system' => 'aws-api',
+            'rpc.service' => service_id,
+            'rpc.method' => context.operation.name,
+            'code.function' => context.operation_name.to_s,
+            'code.namespace' => 'Aws::Plugins::Telemetry'
+          }
+          context.tracer.in_span(
+            parent_span_name(context, service_id),
+            attributes: attributes,
+            kind: Aws::Telemetry::SpanKind::CLIENT,
+            &block
+          )
+        end
+
+        def service_id(context)
+          context.config.api.metadata['serviceId'] ||
+            context.config.api.metadata['serviceAbbreviation'] ||
+            context.config.api.metadata['serviceFullName']
+        end
+
+        def parent_span_name(context, service_id)
+          "#{service_id}.#{context.operation.name}".delete(' ')
+        end
+      end
+
+      handler(Handler, step: :initialize, priority: 99)
+    end
+  end
+end

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

@@ -5,7 +5,8 @@ module Aws
 
     # For Streaming Input Operations, when `requiresLength` is enabled
     # checking whether `Content-Length` header can be set,
-    # for `v4-unsigned-body` operations, set `Transfer-Encoding` header
+    # for `unsignedPayload` and `v4-unsigned-body` operations,
+    # set `Transfer-Encoding` header.
     class TransferEncoding < Seahorse::Client::Plugin
 
       # @api private
@@ -16,8 +17,8 @@ module Aws
             unless context.http_request.body.respond_to?(:size)
               if requires_length?(context.operation.input)
                 # if size of the IO is not available but required
-                raise Aws::Errors::MissingContentLength.new
-              elsif context.operation['authtype'] == "v4-unsigned-body"
+                raise Aws::Errors::MissingContentLength
+              elsif unsigned_payload?(context.operation)
                 context.http_request.headers['Transfer-Encoding'] = 'chunked'
               end
             end
@@ -29,18 +30,24 @@ module Aws
         private
 
         def streaming?(ref)
-          if payload = ref[:payload_member]
-            payload["streaming"] || # checking ref and shape
-              payload.shape["streaming"]
+          if (payload = ref[:payload_member])
+            payload['streaming'] || payload.shape['streaming']
           else
             false
           end
         end
 
+        def unsigned_payload?(operation)
+          operation['unsignedPayload'] ||
+            operation['authtype'] == 'v4-unsigned-body'
+        end
+
         def requires_length?(ref)
-          payload = ref[:payload_member]
-          payload["requiresLength"] || # checking ref and shape
-            payload.shape["requiresLength"]
+          if (payload = ref[:payload_member])
+            payload['requiresLength'] || payload.shape['requiresLength']
+          else
+            false
+          end
         end
 
       end

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

@@ -4,6 +4,31 @@ module Aws
   module Plugins
     # @api private
     class UserAgent < Seahorse::Client::Plugin
+      METRICS = Aws::Json.load(<<-METRICS)
+        {
+          "RESOURCE_MODEL": "A",
+          "WAITER": "B",
+          "PAGINATOR": "C",
+          "RETRY_MODE_LEGACY": "D",
+          "RETRY_MODE_STANDARD": "E",
+          "RETRY_MODE_ADAPTIVE": "F",
+          "S3_TRANSFER": "G",
+          "S3_CRYPTO_V1N": "H",
+          "S3_CRYPTO_V2": "I",
+          "S3_EXPRESS_BUCKET": "J",
+          "S3_ACCESS_GRANTS": "K",
+          "GZIP_REQUEST_COMPRESSION": "L",
+          "PROTOCOL_RPC_V2_CBOR": "M",
+          "ENDPOINT_OVERRIDE": "N",
+          "ACCOUNT_ID_ENDPOINT": "O",
+          "ACCOUNT_ID_MODE_PREFERRED": "P",
+          "ACCOUNT_ID_MODE_DISABLED": "Q",
+          "ACCOUNT_ID_MODE_REQUIRED": "R",
+          "SIGV4A_SIGNING": "S",
+          "RESOLVED_ACCOUNT_ID": "T"
+        }
+      METRICS
+
       # @api private
       option(:user_agent_suffix)
       # @api private
@@ -14,20 +39,27 @@ module Aws
         doc_type: 'String',
         docstring: <<-DOCS) do |cfg|
 A unique and opaque application ID that is appended to the
-User-Agent header as app/<sdk_ua_app_id>. It should have a
-maximum length of 50.
+User-Agent header as app/sdk_ua_app_id. It should have a
+maximum length of 50. This variable is sourced from environment
+variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.
         DOCS
         app_id = ENV['AWS_SDK_UA_APP_ID']
         app_id ||= Aws.shared_config.sdk_ua_app_id(profile: cfg.profile)
         app_id
       end
 
-      def self.feature(feature, &block)
-        Thread.current[:aws_sdk_core_user_agent_feature] ||= []
-        Thread.current[:aws_sdk_core_user_agent_feature] << "ft/#{feature}"
+      # Deprecated - must exist for old service gems
+      def self.feature(_feature, &block)
+        block.call
+      end
+
+      def self.metric(*metrics, &block)
+        Thread.current[:aws_sdk_core_user_agent_metric] ||= []
+        metrics = metrics.map { |metric| METRICS[metric] }.compact
+        Thread.current[:aws_sdk_core_user_agent_metric].concat(metrics)
         block.call
       ensure
-        Thread.current[:aws_sdk_core_user_agent_feature].pop
+        Thread.current[:aws_sdk_core_user_agent_metric].pop(metrics.size)
       end
 
       # @api private
@@ -48,15 +80,24 @@ maximum length of 50.
 
           def to_s
             ua = "aws-sdk-ruby3/#{CORE_GEM_VERSION}"
-            ua += ' ua/2.0'
-            ua += " #{api_metadata}" if api_metadata
+            ua += ' ua/2.1'
+            if (api_m = api_metadata)
+              ua += " #{api_m}"
+            end
             ua += " #{os_metadata}"
             ua += " #{language_metadata}"
-            ua += " #{env_metadata}" if env_metadata
-            ua += " #{config_metadata}" if config_metadata
-            ua += " #{app_id}" if app_id
-            ua += " #{feature_metadata}" if feature_metadata
-            ua += " #{framework_metadata}" if framework_metadata
+            if (env_m = env_metadata)
+              ua += " #{env_m}"
+            end
+            if (app_id_m = app_id_metadata)
+              ua += " #{app_id_m}"
+            end
+            if (framework_m = framework_metadata)
+              ua += " #{framework_m}"
+            end
+            if (metric_m = metric_metadata)
+              ua += " #{metric_m}"
+            end
             if @context.config.user_agent_suffix
               ua += " #{@context.config.user_agent_suffix}"
             end
@@ -92,7 +133,6 @@ maximum length of 50.
             local_version = Gem::Platform.local.version
             metadata += "##{local_version}" if local_version
             metadata += " md/#{RbConfig::CONFIG['host_cpu']}"
-            metadata
           end
 
           # Used to be RUBY_ENGINE/RUBY_VERSION
@@ -106,11 +146,7 @@ maximum length of 50.
             "exec-env/#{execution_env}"
           end
 
-          def config_metadata
-            "cfg/retry-mode##{@context.config.retry_mode}"
-          end
-
-          def app_id
+          def app_id_metadata
             return unless (app_id = @context.config.sdk_ua_app_id)
 
             # Sanitize and only allow these characters
@@ -118,12 +154,6 @@ maximum length of 50.
             "app/#{app_id}"
           end
 
-          def feature_metadata
-            return unless Thread.current[:aws_sdk_core_user_agent_feature]
-
-            Thread.current[:aws_sdk_core_user_agent_feature].join(' ')
-          end
-
           def framework_metadata
             if (frameworks_cfg = @context.config.user_agent_frameworks).empty?
               return
@@ -140,10 +170,24 @@ maximum length of 50.
             end
             frameworks.map { |n, v| "lib/#{n}##{v}" }.join(' ')
           end
+
+          def metric_metadata
+            if Thread.current[:aws_sdk_core_user_agent_metric].nil? ||
+               Thread.current[:aws_sdk_core_user_agent_metric].empty?
+              return
+            end
+
+            metrics = Thread.current[:aws_sdk_core_user_agent_metric].join(',')
+            # Metric metadata is limited to 1024 bytes
+            return "m/#{metrics}" if metrics.bytesize <= 1024
+
+            # Removes the last unfinished metric
+            "m/#{metrics[0...metrics[0..1024].rindex(',')]}"
+          end
         end
       end
 
-      handler(Handler, priority: 1)
+      handler(Handler, step: :sign, priority: 97)
     end
   end
 end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Aws
+  # setup autoloading for Plugins
+  # Most plugins are required explicitly from service clients
+  # but users may reference them outside of client usage.
+  module Plugins
+    autoload :ApiKey, 'aws-sdk-core/plugins/api_key'
+    autoload :BearerAuthorization, 'aws-sdk-core/plugins/bearer_authorization'
+    autoload :ChecksumAlgorithm, 'aws-sdk-core/plugins/checksum_algorithm'
+    autoload :ClientMetricsPlugin, 'aws-sdk-core/plugins/client_metrics_plugin'
+    autoload :ClientMetricsSendPlugin, 'aws-sdk-core/plugins/client_metrics_send_plugin'
+    autoload :CredentialsConfiguration, 'aws-sdk-core/plugins/credentials_configuration'
+    autoload :DefaultsMode, 'aws-sdk-core/plugins/defaults_mode'
+    autoload :EndpointDiscovery, 'aws-sdk-core/plugins/endpoint_discovery'
+    autoload :EndpointPattern, 'aws-sdk-core/plugins/endpoint_pattern'
+    autoload :EventStreamConfiguration, 'aws-sdk-core/plugins/event_stream_configuration'
+    autoload :GlobalConfiguration, 'aws-sdk-core/plugins/global_configuration'
+    autoload :HelpfulSocketErrors, 'aws-sdk-core/plugins/helpful_socket_errors'
+    autoload :HttpChecksum, 'aws-sdk-core/plugins/http_checksum'
+    autoload :IdempotencyToken, 'aws-sdk-core/plugins/idempotency_token'
+    autoload :InvocationId, 'aws-sdk-core/plugins/invocation_id'
+    autoload :JsonvalueConverter, 'aws-sdk-core/plugins/jsonvalue_converter'
+    autoload :Logging, 'aws-sdk-core/plugins/logging'
+    autoload :ParamConverter, 'aws-sdk-core/plugins/param_converter'
+    autoload :ParamValidator, 'aws-sdk-core/plugins/param_validator'
+    autoload :RecursionDetection, 'aws-sdk-core/plugins/recursion_detection'
+    autoload :RegionalEndpoint, 'aws-sdk-core/plugins/regional_endpoint'
+    autoload :RequestCompression, 'aws-sdk-core/plugins/request_compression'
+    autoload :ResponsePaging, 'aws-sdk-core/plugins/response_paging'
+    autoload :RetryErrors, 'aws-sdk-core/plugins/retry_errors'
+    autoload :Sign, 'aws-sdk-core/plugins/sign'
+    autoload :SignatureV4, 'aws-sdk-core/plugins/signature_v4'
+    autoload :StubResponses, 'aws-sdk-core/plugins/stub_responses'
+    autoload :Telemetry, 'aws-sdk-core/plugins/telemetry'
+    autoload :TransferEncoding, 'aws-sdk-core/plugins/transfer_encoding'
+    autoload :UserAgent, 'aws-sdk-core/plugins/user_agent'
+  end
+end

data/lib/aws-sdk-core/process_credentials.rb

@@ -2,9 +2,15 @@
 
 module Aws
   # A credential provider that executes a given process and attempts
-  # to read its stdout to recieve a JSON payload containing the credentials.
+  # to read its stdout to receive a JSON payload containing the credentials.
   #
-  #     credentials = Aws::ProcessCredentials.new('/usr/bin/credential_proc')
+  #     credentials = Aws::ProcessCredentials.new(['/usr/bin/credential_proc'])
+  #     ec2 = Aws::EC2::Client.new(credentials: credentials)
+  #
+  # Arguments should be provided as strings in the array, for example:
+  #
+  #     process = ['/usr/bin/credential_proc', 'arg1', 'arg2']
+  #     credentials = Aws::ProcessCredentials.new(process)
   #     ec2 = Aws::EC2::Client.new(credentials: credentials)
   #
   # Automatically handles refreshing credentials if an Expiration time is
@@ -19,56 +25,69 @@ module Aws
     # Creates a new ProcessCredentials object, which allows an
     # external process to be used as a credential provider.
     #
-    # @param [String] process Invocation string for process
-    # credentials provider.
+    # @param [Array<String>, String] process An array of strings including
+    #  the process name and its arguments to execute, or a single string to be
+    #  executed by the shell (deprecated and insecure).
     def initialize(process)
+      if process.is_a?(String)
+        warn('Passing a single string to Aws::ProcessCredentials.new '\
+             'is insecure, please use use an array of system arguments instead')
+      end
       @process = process
-      @credentials = credentials_from_process(@process)
+      @credentials = credentials_from_process
       @async_refresh = false
 
       super
     end
 
     private
-    def credentials_from_process(proc_invocation)
-      begin
-        raw_out = `#{proc_invocation}`
-        process_status = $?
-      rescue Errno::ENOENT
-        raise Errors::InvalidProcessCredentialsPayload.new("Could not find process #{proc_invocation}")
+
+    def credentials_from_process
+      r, w = IO.pipe
+      success = system(*@process, out: w)
+      w.close
+      raw_out = r.read
+      r.close
+
+      unless success
+        raise Errors::InvalidProcessCredentialsPayload.new(
+          'credential_process provider failure, the credential process had '\
+          'non zero exit status and failed to provide credentials'
+        )
       end
 
-      if process_status.success?
-        begin
-          creds_json = Aws::Json.load(raw_out)
-        rescue Aws::Json::ParseError
-          raise Errors::InvalidProcessCredentialsPayload.new("Invalid JSON response")
-        end
-        payload_version = creds_json['Version']
-        if payload_version == 1
-          _parse_payload_format_v1(creds_json)
-        else
-          raise Errors::InvalidProcessCredentialsPayload.new("Invalid version #{payload_version} for credentials payload")
-        end
-      else
-        raise Errors::InvalidProcessCredentialsPayload.new('credential_process provider failure, the credential process had non zero exit status and failed to provide credentials')
+      begin
+        creds_json = Aws::Json.load(raw_out)
+      rescue Aws::Json::ParseError
+        raise Errors::InvalidProcessCredentialsPayload.new('Invalid JSON response')
       end
+
+      payload_version = creds_json['Version']
+      return _parse_payload_format_v1(creds_json) if payload_version == 1
+
+      raise Errors::InvalidProcessCredentialsPayload.new(
+        "Invalid version #{payload_version} for credentials payload"
+      )
     end
 
     def _parse_payload_format_v1(creds_json)
       creds = Credentials.new(
         creds_json['AccessKeyId'],
         creds_json['SecretAccessKey'],
-        creds_json['SessionToken']
+        creds_json['SessionToken'],
+        account_id: creds_json['AccountId']
       )
 
       @expiration = creds_json['Expiration'] ? Time.iso8601(creds_json['Expiration']) : nil
       return creds if creds.set?
-      raise Errors::InvalidProcessCredentialsPayload.new("Invalid payload for JSON credentials version 1")
+
+      raise Errors::InvalidProcessCredentialsPayload.new(
+        'Invalid payload for JSON credentials version 1'
+      )
     end
 
     def refresh
-      @credentials = credentials_from_process(@process)
+      @credentials = credentials_from_process
     end
 
     def near_expiration?(expiration_length)

data/lib/aws-sdk-core/query/ec2_handler.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aws
+  # @api private
+  module Query
+    class EC2Handler < Aws::Query::Handler
+
+      def apply_params(param_list, params, rules)
+        Aws::Query::EC2ParamBuilder.new(param_list).apply(rules, params)
+      end
+
+      def parse_xml(context)
+        if (rules = context.operation.output)
+          parser = Xml::Parser.new(rules)
+          parser.parse(xml(context)) do |path, value|
+            if path.size == 2 && path.last == 'requestId'
+              context.metadata[:request_id] = value
+            end
+          end
+        else
+          EmptyStructure.new
+        end
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-core/query/ec2_param_builder.rb

@@ -31,13 +31,11 @@ module Aws
       end
 
       def list(ref, values, prefix)
-        if values.empty?
-          set(prefix, '')
-        else
-          member_ref = ref.shape.member
-          values.each.with_index do |value, n|
-            format(member_ref, value, "#{prefix}.#{n+1}")
-          end
+        return if values.empty?
+
+        member_ref = ref.shape.member
+        values.each.with_index do |value, n|
+          format(member_ref, value, "#{prefix}.#{n + 1}")
         end
       end
 

data/lib/aws-sdk-core/query/handler.rb

@@ -27,13 +27,13 @@ module Aws
       # @return [Seahorse::Client::Response]
       def call(context)
         build_request(context)
-        @handler.call(context).on_success do |response|
-          response.error = nil
+        @handler.call(context).on_success do |resp|
+          resp.error = nil
           parsed = parse_xml(context)
           if parsed.nil? || parsed == EmptyStructure
-            response.data = EmptyStructure.new
+            resp.data = EmptyStructure.new
           else
-            response.data = parsed
+            resp.data = parsed
           end
         end
       end

data/lib/aws-sdk-core/query/param_builder.rb

@@ -36,7 +36,7 @@ module Aws
           return
         end
         if flat?(ref)
-          if name = query_name(member_ref)
+          if (name = query_name(ref))
             parts = prefix.split('.')
             parts.pop
             parts.push(name)
@@ -82,7 +82,7 @@ module Aws
       end
 
       def flat?(ref)
-        ref.shape.flattened
+        ref[:flattened] || ref.shape.flattened
       end
 
       def timestamp(ref, value)

data/lib/aws-sdk-core/query.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'query/ec2_param_builder'
 require_relative 'query/handler'
+require_relative 'query/ec2_handler'
 require_relative 'query/param'
 require_relative 'query/param_builder'
+require_relative 'query/ec2_param_builder'
 require_relative 'query/param_list'

data/lib/aws-sdk-core/refreshing_credentials.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'thread'
-
 module Aws
 
   # Base class used credential classes that can be refreshed. This
@@ -48,6 +46,14 @@ module Aws
 
     private
 
+    def sync_expiration_length
+      self.class::SYNC_EXPIRATION_LENGTH
+    end
+
+    def async_expiration_length
+      self.class::ASYNC_EXPIRATION_LENGTH
+    end
+
     # Refreshes credentials asynchronously and synchronously.
     # If we are near to expiration, block while getting new credentials.
     # Otherwise, if we're approaching expiration, use the existing credentials
@@ -56,18 +62,18 @@ module Aws
       # Note: This check is an optimization. Rather than acquire the mutex on every #refresh_if_near_expiration
       # call, we check before doing so, and then we check within the mutex to avoid a race condition.
       # See issue: https://github.com/aws/aws-sdk-ruby/issues/2641 for more info.
-      if near_expiration?(SYNC_EXPIRATION_LENGTH)
+      if near_expiration?(sync_expiration_length)
         @mutex.synchronize do
-          if near_expiration?(SYNC_EXPIRATION_LENGTH)
+          if near_expiration?(sync_expiration_length)
             @before_refresh.call(self) if @before_refresh
             refresh
           end
         end
-      elsif @async_refresh && near_expiration?(ASYNC_EXPIRATION_LENGTH)
+      elsif @async_refresh && near_expiration?(async_expiration_length)
         unless @mutex.locked?
           Thread.new do
             @mutex.synchronize do
-              if near_expiration?(ASYNC_EXPIRATION_LENGTH)
+              if near_expiration?(async_expiration_length)
                 @before_refresh.call(self) if @before_refresh
                 refresh
               end

data/lib/aws-sdk-core/resources.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Aws
+  # setup autoloading for Resources module
+  module Resources
+    autoload :Collection, 'aws-sdk-core/resources/collection'
+  end
+end