aws-sdk-core 3.202.2 → 3.206.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0072b215b84fdf20732969f2e6c471ba8b5b9a27de261addc0518fe650d31eec
-  data.tar.gz: 01e7506da1222047c1e852fa375b84f104a16476057de6448ad79582d5096345
+  metadata.gz: a367793c192d43de9b14d55b9de1c3d888fcb850b06ab3a257eef6e49e368ee0
+  data.tar.gz: 499e081e6fcb025dcc851ca385c487bcabe38db7f5f71c1f58b7fd8e1a8a0c73
 SHA512:
-  metadata.gz: 4306a917a294c832eb03c3c26257b11d5e20a50224808ade0d71e3856f27c02c0e2e0ea0b9aab2c97718035938de0fd058b2abefb96dae00f07c2d3b1a44eb3c
-  data.tar.gz: 7fed48d60a2e1ae6dcf968af4c4291153417ef22b0b3e8aa69fae68d3b89b88ad43fb5f2d2a453295eb28b45376cb2602bfd3d688d8d7bbde3aa12b5c5e038d5
+  metadata.gz: bcf36ccf81b3452e352a4464962df3d6a7511bee43f2bd16724c2ed9787a79710ae3afb4311be23b069428085f9bbaae3674a63a37f8d55f50c5ab6170536b99
+  data.tar.gz: 4fa01e283a5c31d2d77d01d7037450d34130cd7a997bf05fe1b33bd88c7bd699d706ad76c02791321457e011e5bb23c5859b571ad05a3beb4c02be4fae08ebbf

data/CHANGELOG.md

@@ -1,6 +1,44 @@
 Unreleased Changes
 ------------------
 
+3.206.0 (2024-09-17)
+------------------
+
+* Feature - Support `sigv4a` endpoint auth without CRT.
+
+3.205.0 (2024-09-11)
+------------------
+
+* Feature - Updated Aws::STS::Client with the latest API changes.
+
+* Feature - Updated Aws::SSOOIDC::Client with the latest API changes.
+
+* Feature - Updated Aws::SSO::Client with the latest API changes.
+
+* Issue - Additional metrics collection in the User-Agent plugin.
+
+3.204.0 (2024-09-10)
+------------------
+
+* Feature - Updated Aws::STS::Client with the latest API changes.
+
+* Feature - Updated Aws::SSOOIDC::Client with the latest API changes.
+
+* Feature - Updated Aws::SSO::Client with the latest API changes.
+
+* Issue - Add support for `ssl_cert` and `ssl_key` configuration options to support mTLS.
+
+3.203.0 (2024-09-03)
+------------------
+
+* Feature - Updated Aws::STS::Client with the latest API changes.
+
+* Feature - Updated Aws::SSOOIDC::Client with the latest API changes.
+
+* Feature - Updated Aws::SSO::Client with the latest API changes.
+
+* Feature - Add support for Observability which includes a configuration, `telemetry_provider` and an OpenTelemetry-based telemetry provider.
+
 3.202.2 (2024-08-30)
 ------------------
 

data/VERSION

@@ -1 +1 @@
-3.202.2
+3.206.0

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

@@ -19,9 +19,12 @@ require 'aws-sigv4'
 module Aws
   # @api private
   module Endpoints
-    supported_auth_traits = %w[aws.auth#sigv4 smithy.api#httpBearerAuth smithy.api#noAuth]
-    supported_auth_traits += ['aws.auth#sigv4a'] if Aws::Sigv4::Signer.use_crt?
-    SUPPORTED_AUTH_TRAITS = supported_auth_traits.freeze
+    SUPPORTED_AUTH_TRAITS = %w[
+      aws.auth#sigv4
+      aws.auth#sigv4a
+      smithy.api#httpBearerAuth
+      smithy.api#noAuth
+    ].freeze
 
     class << self
       def resolve_auth_scheme(context, endpoint)

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

@@ -205,6 +205,7 @@ to test or custom endpoints. This should be a valid HTTP(S) URI.
             cfg.override_config(:region, new_region)
           end
         end
+
         # set a default endpoint in config using legacy (endpoints.json) resolver
         def resolve_legacy_endpoint(cfg)
           endpoint_prefix = cfg.api.metadata['endpointPrefix']

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

@@ -49,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
@@ -58,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)
@@ -99,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/user_agent.rb

@@ -17,7 +17,10 @@ module Aws
           "S3_CRYPTO_V2": "I",
           "S3_EXPRESS_BUCKET": "J",
           "S3_ACCESS_GRANTS": "K",
-          "GZIP_REQUEST_COMPRESSION": "L"
+          "GZIP_REQUEST_COMPRESSION": "L",
+          "PROTOCOL_RPC_V2_CBOR": "M",
+          "ENDPOINT_OVERRIDE": "N",
+          "SIGV4A_SIGNING": "S"
         }
       METRICS
 
@@ -45,15 +48,13 @@ variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.
         block.call
       end
 
-      def self.metric(metric, &block)
+      def self.metric(*metrics, &block)
         Thread.current[:aws_sdk_core_user_agent_metric] ||= []
-        Thread.current[:aws_sdk_core_user_agent_metric] << METRICS[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_metric].pop
-        if Thread.current[:aws_sdk_core_user_agent_metric].empty?
-          Thread.current[:aws_sdk_core_user_agent_metric] = nil
-        end
+        Thread.current[:aws_sdk_core_user_agent_metric].pop(metrics.size)
       end
 
       # @api private
@@ -166,7 +167,10 @@ variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.
           end
 
           def metric_metadata
-            return unless Thread.current[:aws_sdk_core_user_agent_metric]
+            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

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

@@ -7,7 +7,7 @@ module Aws
       # @return [Seahorse::Client::Response]
       def call(context)
         build_request(context)
-        response = @handler.call(context)
+        response = with_metric { @handler.call(context) }
         response.on(200..299) { |resp| resp.data = parse_body(context) }
         response.on(200..599) { |_resp| apply_request_id(context) }
         response
@@ -15,6 +15,10 @@ module Aws
 
       private
 
+      def with_metric(&block)
+        Aws::Plugins::UserAgent.metric('PROTOCOL_RPC_V2_CBOR', &block)
+      end
+
       def build_request(context)
         context.http_request.headers['smithy-protocol'] = 'rpc-v2-cbor'
         context.http_request.http_method = 'POST'

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Aws
+  module Telemetry
+    # Base for `TelemetryProvider` classes.
+    # They are used to emit telemetry data. It needs the
+    # following class implementations to function:
+    # * {TracerProviderBase} - A provider that returns a tracer
+    #   instance. Then, a tracer will create spans and those
+    #   spans will contain information in that given moment.
+    # * {ContextManagerBase} - Manages context and used to
+    #   return the current context within a trace.
+    class TelemetryProviderBase
+      # @param [Aws::Telemetry::TracerBase] tracer_provider A provider
+      #  that returns a tracer instance.
+      # @param [Aws::Telemetry::ContextManagerBase] context_manager Manages
+      #  context and used to return the current context.
+      def initialize(tracer_provider: nil, context_manager: nil)
+        @tracer_provider = tracer_provider
+        @context_manager = context_manager
+      end
+
+      # @return [Aws::Telemetry::TracerProviderBase]
+      attr_reader :tracer_provider
+
+      # @return [Aws::Telemetry::ContextManagerBase]
+      attr_reader :context_manager
+    end
+
+    # Base for `TracerProvider` classes.
+    class TracerProviderBase
+      # Returns a Tracer instance.
+      #
+      # @param [String] name Tracer name
+      # @return [Aws::Telemetry::TracerBase]
+      def tracer(name = nil)
+        raise NotImplementedError
+      end
+    end
+
+    # Base for `Tracer` classes.
+    class TracerBase
+      # Used when a caller wants to manage the activation/deactivation and
+      # lifecycle of the Span and its parent manually.
+      #
+      # @param [String] name Span name
+      # @param [Object] with_parent Parent Context
+      # @param [Hash] attributes Attributes to attach to the span
+      # @param [Aws::Telemetry::SpanKind] kind Type of Span
+      # @return [Aws::Telemetry::SpanBase]
+      def start_span(name, with_parent: nil, attributes: nil, kind: nil)
+        raise NotImplementedError
+      end
+
+      # A helper for the default use-case of extending the current trace
+      # with a span.
+      # On exit, the Span that was active before calling this method will
+      # be reactivated. If an exception occurs during the execution of the
+      # provided block, it will be recorded on the span and re-raised.
+      #
+      # @param [String] name Span name
+      # @param [Hash] attributes Attributes to attach to the span
+      # @param [Aws::Telemetry::SpanKind] kind Type of Span
+      # @return [Aws::Telemetry::SpanBase]
+      def in_span(name, attributes: nil, kind: nil)
+        raise NotImplementedError
+      end
+
+      # Returns the current active span.
+      #
+      # @return [Aws::Telemetry::SpanBase]
+      def current_span
+        raise NotImplementedError
+      end
+    end
+
+    # Base for `Span` classes.
+    class SpanBase
+      # Set attribute.
+      #
+      # @param [String] key
+      # @param [String, Boolean, Numeric, Array<String, Numeric, Boolean>] value
+      #   Value must be non-nil and (array of) string, boolean or numeric type.
+      #   Array values must not contain nil elements and all elements must be of
+      #   the same basic type (string, numeric, boolean)
+      # @return [self] returns itself
+      def set_attribute(key, value)
+        raise NotImplementedError
+      end
+      alias []= set_attribute
+
+      # Add attributes.
+      #
+      # @param [Hash{String => String, Numeric, Boolean, Array<String, Numeric,
+      #   Boolean>}] attributes Values must be non-nil and (array of) string,
+      #   boolean or numeric type. Array values must not contain nil elements
+      #   and all elements must be of the same basic type (string, numeric,
+      #   boolean)
+      # @return [self] returns itself
+      def add_attributes(attributes)
+        raise NotImplementedError
+      end
+
+      # Add event to a Span.
+      #
+      # @param [String] name Name of the event
+      # @param [Hash{String => String, Numeric, Boolean, Array<String,
+      #   Numeric, Boolean>}] attributes Values must be non-nil and (array of)
+      #   string, boolean or numeric type. Array values must not contain nil
+      #   elements and all elements must be of the same basic type (string,
+      #   numeric, boolean)
+      # @return [self] returns itself
+      def add_event(name, attributes: nil)
+        raise NotImplementedError
+      end
+
+      # Sets the Span status.
+      #
+      # @param [Aws::Telemetry::SpanStatus] status The new status, which
+      #   overrides the default Span status, which is `OK`
+      # @return [void]
+      def status=(status)
+        raise NotImplementedError
+      end
+
+      # Finishes the Span.
+      #
+      # @param [Time] end_timestamp End timestamp for the span.
+      # @return [self] returns itself
+      def finish(end_timestamp: nil)
+        raise NotImplementedError
+      end
+
+      # Record an exception during the execution of this span. Multiple
+      # exceptions can be recorded on a span.
+      #
+      # @param [Exception] exception The exception to be recorded
+      # @param [Hash{String => String, Numeric, Boolean, Array<String,
+      #   Numeric, Boolean>}] attributes One or more key:value pairs, where the
+      #   keys must be strings and the values may be (array of) string, boolean
+      #   or numeric type.
+      # @return [void]
+      def record_exception(exception, attributes: nil)
+        raise NotImplementedError
+      end
+    end
+
+    # Base for all `ContextManager` classes.
+    class ContextManagerBase
+      # Returns current context.
+      #
+      # @return [Context]
+      def current
+        raise NotImplementedError
+      end
+
+      # Associates a Context with the caller’s current execution unit.
+      # Returns a token to be used with the matching call to detach.
+      #
+      # @param [Object] context The new context
+      # @return [Object] token A token to be used when detaching
+      def attach(context)
+        raise NotImplementedError
+      end
+
+      # Restore the previous Context associated with the current
+      # execution unit to the value it had before attaching a
+      # specified Context.
+      #
+      # @param [Object] token The token provided by matching the call to attach
+      # @return [Boolean] `True` if the calls matched, `False` otherwise
+      def detach(token)
+        raise NotImplementedError
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Aws
+  module Telemetry
+    # No-op implementation for {TelemetryProviderBase}.
+    class NoOpTelemetryProvider < TelemetryProviderBase
+      def initialize
+        super(
+          tracer_provider: NoOpTracerProvider.new,
+          context_manager: NoOpContextManager.new
+        )
+      end
+    end
+
+    # No-op implementation for {TracerProviderBase}.
+    class NoOpTracerProvider < TracerProviderBase
+      def tracer(name = nil)
+        @tracer ||= NoOpTracer.new
+      end
+    end
+
+    # No-op implementation for {TracerBase}.
+    class NoOpTracer < TracerBase
+      def start_span(name, with_parent: nil, attributes: nil, kind: nil)
+        NoOpSpan.new
+      end
+
+      def in_span(name, attributes: nil, kind: nil)
+        yield NoOpSpan.new
+      end
+
+      def current_span
+        NoOpSpan.new
+      end
+    end
+
+    # No-op implementation for {SpanBase}.
+    class NoOpSpan < SpanBase
+      def set_attribute(key, value)
+        self
+      end
+      alias []= set_attribute
+
+      def add_attributes(attributes)
+        self
+      end
+
+      def add_event(name, attributes: nil)
+        self
+      end
+
+      def status=(status); end
+
+      def finish(end_timestamp: nil)
+        self
+      end
+
+      def record_exception(exception, attributes: nil); end
+    end
+
+    # No-op implementation for {ContextManagerBase}.
+    class NoOpContextManager < ContextManagerBase
+      def current; end
+
+      def attach(context); end
+
+      def detach(token); end
+    end
+  end
+end