aws-sdk-core 3.181.0 → 3.209.1

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

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Aws
+  module Telemetry
+    # OTelProvider allows to emit telemetry data based on OpenTelemetry.
+    #
+    # To use this provider, require the `opentelemetry-sdk` gem and then,
+    # pass in an instance of a `Aws::Telemetry::OTelProvider` as the
+    # telemetry provider in the client config.
+    #
+    # @example Configuration
+    #     require 'opentelemetry-sdk'
+    #
+    #     # sets up the OpenTelemetry SDK with their config defaults
+    #     OpenTelemetry::SDK.configure
+    #
+    #     otel_provider = Aws::Telemetry::OTelProvider.new
+    #     client = Aws::S3::Client.new(telemetry_provider: otel_provider)
+    #
+    # OpenTelemetry supports many ways to export your telemetry data.
+    # See {https://opentelemetry.io/docs/languages/ruby/exporters here} for
+    # more information.
+    #
+    # @example Exporting via console
+    #     require 'opentelemetry-sdk'
+    #
+    #     ENV['OTEL_TRACES_EXPORTER'] ||= 'console'
+    #
+    #     # configures the OpenTelemetry SDK with defaults
+    #     OpenTelemetry::SDK.configure
+    #
+    #     otel_provider = Aws::Telemetry::OTelProvider.new
+    #     client = Aws::S3::Client.new(telemetry_provider: otel_provider)
+    class OTelProvider < TelemetryProviderBase
+      def initialize
+        unless otel_loaded?
+          raise ArgumentError,
+                'Requires the `opentelemetry-sdk` gem to use OTel Provider.'
+        end
+        super(
+          tracer_provider: OTelTracerProvider.new,
+          context_manager: OTelContextManager.new
+        )
+      end
+
+      private
+
+      def otel_loaded?
+        if @use_otel.nil?
+          @use_otel =
+            begin
+              require 'opentelemetry-sdk'
+              true
+            rescue LoadError, NameError
+              false
+            end
+        end
+        @use_otel
+      end
+    end
+
+    # OpenTelemetry-based {TracerProviderBase}, an entry point for
+    # creating Tracer instances.
+    class OTelTracerProvider < TracerProviderBase
+      def initialize
+        super
+        @tracer_provider = OpenTelemetry.tracer_provider
+      end
+
+      # Returns a Tracer instance.
+      #
+      # @param [optional String] name Tracer name
+      # @return [Aws::Telemetry::OTelTracer]
+      def tracer(name = nil)
+        OTelTracer.new(@tracer_provider.tracer(name))
+      end
+    end
+
+    # OpenTelemetry-based {TracerBase}, responsible for creating spans.
+    class OTelTracer < TracerBase
+      def initialize(tracer)
+        super()
+        @tracer = tracer
+      end
+
+      # 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::OTelSpan]
+      def start_span(name, with_parent: nil, attributes: nil, kind: nil)
+        span = @tracer.start_span(
+          name,
+          with_parent: with_parent,
+          attributes: attributes,
+          kind: kind
+        )
+        OTelSpan.new(span)
+      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::OTelSpan]
+      def in_span(name, attributes: nil, kind: nil, &block)
+        @tracer.in_span(name, attributes: attributes, kind: kind) do |span|
+          block.call(OTelSpan.new(span))
+        end
+      end
+
+      # Returns the current active span.
+      #
+      # @return [Aws::Telemetry::OTelSpan]
+      def current_span
+        OTelSpan.new(OpenTelemetry::Trace.current_span)
+      end
+    end
+
+    # OpenTelemetry-based {SpanBase}, represents a single operation
+    # within a trace.
+    class OTelSpan < SpanBase
+      def initialize(span)
+        super()
+        @span = span
+      end
+
+      # 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)
+        @span.set_attribute(key, value)
+      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)
+        @span.add_attributes(attributes)
+      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)
+        @span.add_event(name, attributes: attributes)
+      end
+
+      # Sets the Span status.
+      #
+      # @param [Aws::Telemetry::Status] status The new status, which
+      #   overrides the default Span status, which is `OK`
+      # @return [void]
+      def status=(status)
+        @span.status = status
+      end
+
+      # Finishes the Span.
+      #
+      # @param [Time] end_timestamp End timestamp for the span
+      # @return [self] returns itself
+      def finish(end_timestamp: nil)
+        @span.finish(end_timestamp: end_timestamp)
+      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)
+        @span.record_exception(exception, attributes: attributes)
+      end
+    end
+
+    # OpenTelemetry-based {ContextManagerBase}, manages context and
+    # used to return the current context within a trace.
+    class OTelContextManager < ContextManagerBase
+      # Returns current context.
+      #
+      # @return [Context]
+      def current
+        OpenTelemetry::Context.current
+      end
+
+      # Associates a Context with the caller’s current execution unit.
+      # Returns a token to be used with the matching call to detach.
+      #
+      # @param [Context] context The new context
+      # @return [Object] token A token to be used when detaching
+      def attach(context)
+        OpenTelemetry::Context.attach(context)
+      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)
+        OpenTelemetry::Context.detach(token)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Aws
+  module Telemetry
+    module SpanKind
+      # Default. Represents an internal operation within an application.
+      INTERNAL = :internal
+
+      # Represents handling synchronous network requests.
+      SERVER = :server
+
+      # Represents a request to some remote service.
+      CLIENT = :client
+
+      # Represents a child of an asynchronous `PRODUCER` request.
+      CONSUMER = :consumer
+
+      # Represents an asynchronous request.
+      PRODUCER = :producer
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Aws
+  module Telemetry
+    # Represents the status of a finished span.
+    class SpanStatus
+      class << self
+        private :new
+
+        # Returns a newly created {SpanStatus} with code, `UNSET`
+        # and an optional description.
+        #
+        # @param [optional String] description
+        # @return [SpanStatus]
+        def unset(description = '')
+          new(UNSET, description: description)
+        end
+
+        # Returns a newly created {SpanStatus} with code, `OK`
+        # and an optional description.
+        #
+        # @param [optional String] description
+        # @return [SpanStatus]
+        def ok(description = '')
+          new(OK, description: description)
+        end
+
+        # Returns a newly created {SpanStatus} with code, `ERROR`
+        # and an optional description.
+        #
+        # @param [optional String] description
+        # @return [SpanStatus]
+        def error(description = '')
+          new(ERROR, description: description)
+        end
+      end
+
+      def initialize(code, description: '')
+        @code = code
+        @description = description
+      end
+
+      # @return [Integer] code
+      attr_reader :code
+
+      # @return [String] description
+      attr_reader :description
+
+      # The operation completed successfully.
+      OK = 0
+
+      # The default status.
+      UNSET = 1
+
+      # An error.
+      ERROR = 2
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'telemetry/base'
+require_relative 'telemetry/no_op'
+require_relative 'telemetry/otel'
+require_relative 'telemetry/span_kind'
+require_relative 'telemetry/span_status'
+
+module Aws
+  # Observability is the extent to which a system's current state can be
+  # inferred from the data it emits. The data emitted is commonly referred
+  # as Telemetry. The AWS SDK for Ruby currently supports traces as
+  # a telemetry signal.
+  #
+  # A telemetry provider is used to emit telemetry data. By default, the
+  # {NoOpTelemetryProvider} will not record or emit any telemetry data.
+  # The SDK currently supports OpenTelemetry (OTel) as a provider. See
+  # {OTelProvider} for more information.
+  #
+  # If a provider isn't supported, you can implement your own provider by
+  # inheriting the following base classes and implementing the interfaces
+  # defined:
+  # * {TelemetryProviderBase}
+  # * {ContextManagerBase}
+  # * {TracerProviderBase}
+  # * {TracerBase}
+  # * {SpanBase}
+  module Telemetry
+    class << self
+      # @api private
+      def module_to_tracer_name(module_name)
+        "#{module_name.gsub('::', '.')}.client".downcase
+      end
+
+      # @api private
+      def http_request_attrs(context)
+        {
+          'http.method' => context.http_request.http_method,
+          'net.protocol.name' => 'http'
+        }.tap do |h|
+          h['net.protocol.version'] =
+            if context.client.is_a? Seahorse::Client::AsyncBase
+              '2'
+            else
+              Net::HTTP::HTTPVersion
+            end
+
+          unless context.config.stub_responses
+            h['net.peer.name'] = context.http_request.endpoint.host
+            h['net.peer.port'] = context.http_request.endpoint.port.to_s
+          end
+
+          if context.http_request.headers.key?('Content-Length')
+            h['http.request_content_length'] =
+              context.http_request.headers['Content-Length']
+          end
+        end
+      end
+
+      # @api private
+      def http_response_attrs(context)
+        {
+          'http.status_code' => context.http_response.status_code.to_s
+        }.tap do |h|
+          if context.http_response.headers.key?('Content-Length')
+            h['http.response_content_length'] =
+              context.http_response.headers['Content-Length']
+          end
+
+          if context.http_response.headers.key?('x-amz-request-id')
+            h['aws.request_id'] =
+              context.http_response.headers['x-amz-request-id']
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -67,6 +67,45 @@ module Aws
         end
       end
 
+      # @param [Number] input
+      # @return [Number, String] The serialized number
+      def serialize_number(input)
+        if input == ::Float::INFINITY then 'Infinity'
+        elsif input == -::Float::INFINITY then '-Infinity'
+        elsif input&.nan? then 'NaN'
+        else
+          input
+        end
+      end
+
+      # @param [String] str
+      # @return [Number] The input as a number
+      def deserialize_number(str)
+        case str
+        when 'Infinity' then ::Float::INFINITY
+        when '-Infinity' then -::Float::INFINITY
+        when 'NaN' then ::Float::NAN
+        when nil then nil
+        else str.to_f
+        end
+      end
+
+      # @param [String] value
+      # @return [Time]
+      def deserialize_time(value)
+        case value
+        when nil then nil
+        when /^[\d.]+$/ then Time.at(value.to_f).utc
+        else
+          begin
+            fractional_time = Time.parse(value).to_f
+            Time.at(fractional_time).utc
+          rescue ArgumentError
+            raise "unhandled timestamp format `#{value}'"
+          end
+        end
+      end
+
     end
   end
 end

data/lib/aws-sdk-core/waiters/poller.rb

@@ -29,7 +29,7 @@ module Aws
       # * `:retry`   - The waiter may be retried.
       # * `:error`   - The waiter encountered an un-expected error.
       #
-      # @example A trival (bad) example of a waiter that polls indefinetly.
+      # @example A trivial (bad) example of a waiter that polls indefinetly.
       #
       #   loop do
       #
@@ -62,7 +62,7 @@ module Aws
       def send_request(options)
         req = options[:client].build_request(@operation_name, options[:params])
         req.handlers.remove(RAISE_HANDLER)
-        Aws::Plugins::UserAgent.feature('waiter') do
+        Aws::Plugins::UserAgent.metric('WAITER') do
           req.send_request
         end
       end
@@ -96,8 +96,13 @@ module Aws
       end
 
       def matches_error?(acceptor, response)
-        Aws::Errors::ServiceError === response.error &&
-        response.error.code == acceptor['expected'].gsub('.', '')
+        case acceptor['expected']
+        when 'false' then response.error.nil?
+        when 'true' then !response.error.nil?
+        else
+          response.error.is_a?(Aws::Errors::ServiceError) &&
+            response.error.code == acceptor['expected'].delete('.')
+        end
       end
 
       def path(acceptor)
@@ -107,7 +112,7 @@ module Aws
       def non_empty_array(acceptor, response, &block)
         if response.data
           values = JMESPath.search(path(acceptor), response.data)
-          Array === values && values.count > 0 ? yield(values) : false
+          values.is_a?(Array) && values.count > 0 ? yield(values) : false
         else
           false
         end

data/lib/aws-sdk-core/xml/builder.rb

@@ -10,6 +10,8 @@ module Aws
 
       def initialize(rules, options = {})
         @rules = rules
+        @location_name =
+          options[:location_name].nil? ? @rules.location_name : options[:location_name]
         @xml = options[:target] || []
         indent = options[:indent] || ''
         pad = options[:pad] || ''
@@ -17,7 +19,7 @@ module Aws
       end
 
       def to_xml(params)
-        structure(@rules.location_name, @rules, params)
+        structure(@location_name, @rules, params)
         @xml.join
       end
       alias serialize to_xml
@@ -50,7 +52,7 @@ module Aws
       def list(name, ref, values)
         if ref[:flattened] || ref.shape.flattened
           values.each do |value|
-            member(ref.shape.member.location_name || name, ref.shape.member, value)
+            member(name, ref.shape.member, value)
           end
         else
           node(name, ref) do
@@ -65,7 +67,7 @@ module Aws
       def map(name, ref, hash)
         key_ref = ref.shape.key
         value_ref = ref.shape.value
-        if ref.shape.flattened
+        if ref[:flattened] || ref.shape.flattened
           hash.each do |key, value|
             node(name, ref) do
               member(key_ref.location_name || 'key', key_ref, key)
@@ -75,7 +77,8 @@ module Aws
         else
           node(name, ref) do
             hash.each do |key, value|
-              node('entry', ref)  do
+              # Pass in a new ShapeRef to create an entry node
+              node('entry', ShapeRef.new) do
                 member(key_ref.location_name || 'key', key_ref, key)
                 member(value_ref.location_name || 'value', value_ref, value)
               end
@@ -129,11 +132,16 @@ module Aws
       end
 
       def shape_attrs(ref)
-        if xmlns = ref['xmlNamespace']
-          if prefix = xmlns['prefix']
-            { 'xmlns:' + prefix => xmlns['uri'] }
-          else
-            { 'xmlns' => xmlns['uri'] }
+        if (xmlns = ref['xmlNamespace'])
+          case xmlns
+          when String
+            { 'xmlns' => xmlns }
+          when Hash
+            if (prefix = xmlns['prefix'])
+              { "xmlns:#{prefix}" => xmlns['uri'] }
+            else
+              { 'xmlns' => xmlns['uri'] }
+            end
           end
         else
           {}

data/lib/aws-sdk-core/xml/error_handler.rb

@@ -4,7 +4,7 @@ require 'cgi'
 
 module Aws
   module Xml
-    class ErrorHandler < Seahorse::Client::Handler
+    class ErrorHandler < Aws::ErrorHandler
 
       def call(context)
         @handler.call(context).on(300..599) do |response|
@@ -15,42 +15,29 @@ module Aws
 
       private
 
-      def error(context)
-        body = context.http_response.body_contents
-        if body.empty?
-          code = http_status_error_code(context)
-          message = ''
-          data = EmptyStructure.new
-        else
-          code, message, data = extract_error(body, context)
-        end
-        context[:request_id] = request_id(body)
-        errors_module = context.client.class.errors_module
-        error_class = errors_module.error_class(code).new(context, message, data)
-        error_class
-      end
-
       def extract_error(body, context)
+        context[:request_id] = request_id(body)
         code = error_code(body, context)
         [
           code,
           error_message(body),
-          error_data(context, code)
+          error_data(context, body, code)
         ]
       end
 
-      def error_data(context, code)
+      def error_data(context, body, code)
         data = EmptyStructure.new
-        if error_rules = context.operation.errors
+        if (error_rules = context.operation.errors)
           error_rules.each do |rule|
-            # for modeled shape with error trait
-            # match `code` in the error trait before
-            # match modeled shape name
+            # query protocol may have custom error code
+            # reference: https://smithy.io/2.0/aws/protocols/aws-query-protocol.html#error-code-resolution
             error_shape_code = rule.shape['error']['code'] if rule.shape['error']
             match = (code == error_shape_code || code == rule.shape.name)
-            if match && rule.shape.members.any?
-              data = Parser.new(rule).parse(context.http_response.body_contents)
-            end
+            next unless match && rule.shape.members.any?
+
+            data = parse_error_data(rule, body)
+            # supporting HTTP bindings
+            apply_error_headers(rule, context, data)
           end
         end
         data
@@ -58,29 +45,32 @@ module Aws
         EmptyStructure.new
       end
 
+      def parse_error_data(rule, body)
+        # errors may nested under <Errors><Error>structure_data</Error></Errors>
+        # Or may be flat and under <Error>structure_data</Error>
+        body = body.tr("\n", '')
+        if (matches = body.match(/<Error>(.+?)<\/Error>/))
+          Parser.new(rule).parse("<#{rule.shape.name}>#{matches[1]}</#{rule.shape.name}>")
+        else
+          EmptyStructure.new
+        end
+      end
+
+      def apply_error_headers(rule, context, data)
+        headers = Aws::Rest::Response::Headers.new(rule)
+        headers.apply(context.http_response, data)
+      end
+
       def error_code(body, context)
-        if matches = body.match(/<Code>(.+?)<\/Code>/)
+        if (matches = body.match(/<Code>(.+?)<\/Code>/))
           remove_prefix(unescape(matches[1]), context)
         else
           http_status_error_code(context)
         end
       end
 
-      def http_status_error_code(context)
-        status_code = context.http_response.status_code
-        {
-          302 => 'MovedTemporarily',
-          304 => 'NotModified',
-          400 => 'BadRequest',
-          403 => 'Forbidden',
-          404 => 'NotFound',
-          412 => 'PreconditionFailed',
-          413 => 'RequestEntityTooLarge',
-        }[status_code] || "Http#{status_code}Error"
-      end
-
       def remove_prefix(error_code, context)
-        if prefix = context.config.api.metadata['errorPrefix']
+        if (prefix = context.config.api.metadata['errorPrefix'])
           error_code.sub(/^#{prefix}/, '')
         else
           error_code
@@ -88,7 +78,7 @@ module Aws
       end
 
       def error_message(body)
-        if matches = body.match(/<Message>(.+?)<\/Message>/m)
+        if (matches = body.match(/<Message>(.+?)<\/Message>/m))
           unescape(matches[1])
         else
           ''
@@ -96,7 +86,7 @@ module Aws
       end
 
       def request_id(body)
-        if matches = body.match(/<RequestId>(.+?)<\/RequestId>/m)
+        if (matches = body.match(/<RequestId>(.+?)<\/RequestId>/m))
           matches[1]
         end
       end