aws-sdk-core 2.3.23 → 3.89.1

data/lib/aws-sdk-core/binary/event_parser.rb

@@ -0,0 +1,134 @@
+module Aws
+  module Binary
+    # @api private
+    class EventParser
+
+      include Seahorse::Model::Shapes
+
+      # @param [Class] parser_class
+      # @param [Seahorse::Model::ShapeRef] rules (of eventstream member)
+      # @param [Array] error_refs array of errors ShapeRef
+      # @param [Seahorse::Model::ShapeRef] output_ref
+      def initialize(parser_class, rules, error_refs, output_ref)
+        @parser_class = parser_class
+        @rules = rules
+        @error_refs = error_refs
+        @output_ref = output_ref
+      end
+
+      # Parse raw event message into event struct
+      # based on its ShapeRef
+      #
+      # @return [Struct] Event Struct
+      def apply(raw_event)
+        parse(raw_event)
+      end
+
+      private
+
+      def parse(raw_event)
+        message_type = raw_event.headers.delete(":message-type")
+        if message_type
+          case message_type.value
+          when 'error'
+            parse_error_event(raw_event)
+          when 'event'
+            parse_event(raw_event)
+          when 'exception'
+            parse_exception(raw_event)
+          else
+            raise Aws::Errors::EventStreamParserError.new(
+              'Unrecognized :message-type value for the event')
+          end
+        else
+          # no :message-type header, regular event by default
+          parse_event(raw_event)
+        end
+      end
+
+      def parse_exception(raw_event)
+        exception_type = raw_event.headers.delete(":exception-type").value
+        name, ref = @rules.shape.member_by_location_name(exception_type)
+        # exception lives in payload implictly
+        exception = parse_payload(raw_event.payload.read, ref)
+        exception.event_type = name
+        exception
+      end
+
+      def parse_error_event(raw_event)
+        error_code = raw_event.headers.delete(":error-code")
+        error_message = raw_event.headers.delete(":error-message")
+        Aws::Errors::EventError.new(
+          :error,
+          error_code ? error_code.value : error_code,
+          error_message ? error_message.value : error_message
+        )
+      end
+
+      def parse_event(raw_event)
+        event_type = raw_event.headers.delete(":event-type").value
+        # content_type = raw_event.headers.delete(":content-type").value
+
+        if event_type == 'initial-response'
+          event = Struct.new(:event_type, :response).new
+          event.event_type = :initial_response
+          event.response = parse_payload(raw_event.payload.read, @output_ref)
+          return event
+        end
+
+        # locate event from eventstream
+        name, ref = @rules.shape.member_by_location_name(event_type)
+        unless ref.event
+          raise Aws::Errors::EventStreamParserError.new(
+            "Failed to locate event shape for the event")
+        end
+
+        event = ref.shape.struct_class.new
+
+        explicit_payload = false
+        implicit_payload_members = {}
+        ref.shape.members.each do |member_name, member_ref|
+          unless member_ref.eventheader
+            if member_ref.eventpayload
+              explicit_payload = true
+            else
+              implicit_payload_members[member_name] = member_ref
+            end
+          end
+        end
+
+        # implicit payload
+        if !explicit_payload && !implicit_payload_members.empty?
+          event = parse_payload(raw_event.payload.read, ref)
+        end
+        event.event_type = name
+
+        # locate payload and headers in the event
+        ref.shape.members.each do |member_name, member_ref|
+          if member_ref.eventheader
+            # allow incomplete event members in response
+            if raw_event.headers.key?(member_ref.location_name)
+              event.send("#{member_name}=", raw_event.headers[member_ref.location_name].value)
+            end
+          elsif member_ref.eventpayload
+            # explicit payload
+            eventpayload_streaming?(member_ref) ?
+             event.send("#{member_name}=", raw_event.payload) :
+             event.send("#{member_name}=", parse_payload(raw_event.payload.read, member_ref))
+          end
+        end
+        event
+      end
+
+      def eventpayload_streaming?(ref)
+        BlobShape === ref.shape || StringShape === ref.shape
+      end
+
+      def parse_payload(body, rules)
+        @parser_class.new(rules).parse(body) if body.size > 0
+      end
+
+    end
+
+  end
+end

data/lib/aws-sdk-core/binary/event_stream_decoder.rb

@@ -0,0 +1,62 @@
+require 'aws-eventstream'
+
+module Aws
+  module Binary
+    # @api private
+    class EventStreamDecoder
+
+      # @param [String] protocol
+      # @param [ShapeRef] rules ShapeRef of the eventstream member
+      # @param [ShapeRef] output_ref ShapeRef of output shape
+      # @param [Array] error_refs array of ShapeRefs for errors
+      # @param [EventStream|nil] event_stream_handler A Service EventStream object
+      # that registered with callbacks for processing events when they arrive
+      def initialize(protocol, rules, output_ref, error_refs, io, event_stream_handler = nil)
+        @decoder = Aws::EventStream::Decoder.new
+        @event_parser = EventParser.new(parser_class(protocol), rules, error_refs, output_ref)
+        @stream_class = extract_stream_class(rules.shape.struct_class)
+        @emitter = event_stream_handler.event_emitter
+        @events = []
+      end
+
+      # @return [Array] events Array of arrived event objects
+      attr_reader :events
+
+      def write(chunk)
+        raw_event, eof = @decoder.decode_chunk(chunk)
+        emit_event(raw_event) if raw_event
+        while !eof
+          # exhaust message_buffer data
+          raw_event, eof = @decoder.decode_chunk
+          emit_event(raw_event) if raw_event
+        end
+      end
+
+      private
+
+      def emit_event(raw_event)
+        event = @event_parser.apply(raw_event)
+        @events << event
+        @emitter.signal(event.event_type, event) unless @emitter.nil?
+      end
+
+      def parser_class(protocol)
+        case protocol
+        when 'rest-xml' then Aws::Xml::Parser
+        when 'rest-json' then Aws::Json::Parser
+        when 'json' then Aws::Json::Parser
+        else raise "unsupported protocol #{protocol} for event stream"
+        end
+      end
+
+      def extract_stream_class(type_class)
+        parts = type_class.to_s.split('::')
+        parts.inject(Kernel) do |const, part_name|
+          part_name == 'Types' ? const.const_get('EventStreams')
+            : const.const_get(part_name)
+        end
+      end
+    end
+
+  end
+end

data/lib/aws-sdk-core/binary/event_stream_encoder.rb

@@ -0,0 +1,53 @@
+require 'aws-eventstream'
+
+module Aws
+  module Binary
+    # @api private
+    class EventStreamEncoder
+
+      # @param [String] protocol
+      # @param [ShapeRef] rules ShapeRef of the eventstream member
+      # @param [ShapeRef] input_ref ShapeRef of the input shape
+      # @param [Aws::Sigv4::Signer] signer
+      def initialize(protocol, rules, input_ref, signer)
+        @encoder = Aws::EventStream::Encoder.new
+        @event_builder = EventBuilder.new(serializer_class(protocol), rules)
+        @input_ref = input_ref
+        @rules = rules
+        @signer = signer
+        @prior_signature = nil
+      end
+
+      attr_reader :rules
+
+      attr_accessor :prior_signature
+
+      def encode(event_type, params)
+        if event_type == :end_stream
+          payload = ''
+        else
+          payload = @encoder.encode(@event_builder.apply(event_type, params))
+        end
+        headers, signature = @signer.sign_event(@prior_signature, payload, @encoder)
+        @prior_signature = signature
+        message = Aws::EventStream::Message.new(
+          headers: headers,
+          payload: StringIO.new(payload)
+        )
+        @encoder.encode(message)
+      end
+
+      private
+
+      def serializer_class(protocol)
+        case protocol
+        when 'rest-xml' then Xml::Builder
+        when 'rest-json' then Json::Builder
+        when 'json' then Json::Builder
+        else raise "unsupported protocol #{protocol} for event stream"
+        end
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-core/client_side_monitoring/publisher.rb

@@ -0,0 +1,49 @@
+require 'thread'
+require 'socket'
+
+module Aws
+  module ClientSideMonitoring
+    # @api private
+    class Publisher
+      attr_reader :agent_port
+      attr_reader :agent_host
+
+      def initialize(opts = {})
+        @agent_host = opts[:agent_host] || "127.0.0.1"
+        @agent_port = opts[:agent_port]
+        @mutex = Mutex.new
+      end
+
+      def agent_port=(value)
+        @mutex.synchronize do
+          @agent_port = value
+        end
+      end
+
+      def agent_host=(value)
+        @mutex.synchronize do
+          @agent_host = value
+        end
+      end
+
+      def publish(request_metrics)
+        send_datagram(request_metrics.api_call.to_json)
+        request_metrics.api_call_attempts.each do |attempt|
+          send_datagram(attempt.to_json)
+        end
+      end
+
+      def send_datagram(msg)
+        if @agent_port
+          socket = UDPSocket.new
+          begin
+            socket.connect(@agent_host, @agent_port)
+            socket.send(msg, 0)
+          rescue Errno::ECONNREFUSED
+            # Drop on the floor
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/client_side_monitoring/request_metrics.rb

@@ -0,0 +1,197 @@
+module Aws
+  module ClientSideMonitoring
+    # @api private
+    class RequestMetrics
+      attr_reader :api_call, :api_call_attempts
+
+      FIELD_MAX_LENGTH = {
+        "ClientId" => 255,
+        "UserAgent" => 256,
+        "SdkException" => 128,
+        "SdkExceptionMessage" => 512,
+        "AwsException" => 128,
+        "AwsExceptionMessage" => 512,
+        "FinalAwsException" => 128,
+        "FinalAwsExceptionMessage" => 512,
+        "FinalSdkException" => 128,
+        "FinalSdkExceptionMessage" => 512,
+      }
+
+      def initialize(opts = {})
+        @service = opts[:service]
+        @api = opts[:operation]
+        @client_id = opts[:client_id]
+        @timestamp = opts[:timestamp] # In epoch milliseconds
+        @region = opts[:region]
+        @version = 1
+        @api_call = ApiCall.new(@service, @api, @client_id, @version, @timestamp, @region)
+        @api_call_attempts = []
+      end
+
+      def build_call_attempt(opts = {})
+        timestamp = opts[:timestamp]
+        fqdn = opts[:fqdn]
+        region = opts[:region]
+        user_agent = opts[:user_agent]
+        access_key = opts[:access_key]
+        session_token = opts[:session_token]
+        ApiCallAttempt.new(
+          @service,
+          @api,
+          @client_id,
+          @version,
+          timestamp,
+          fqdn,
+          region,
+          user_agent,
+          access_key,
+          session_token
+        )
+      end
+
+      def add_call_attempt(attempt)
+        @api_call_attempts << attempt
+      end
+
+      class ApiCall
+        attr_reader :service, :api, :client_id, :timestamp, :version,
+          :attempt_count, :latency, :region, :max_retries_exceeded,
+          :final_http_status_code, :user_agent, :final_aws_exception,
+          :final_aws_exception_message, :final_sdk_exception,
+          :final_sdk_exception_message
+
+        def initialize(service, api, client_id, version, timestamp, region)
+          @service = service
+          @api = api
+          @client_id = client_id
+          @version = version
+          @timestamp = timestamp
+          @region = region
+        end
+
+        def complete(opts = {})
+          @latency = opts[:latency]
+          @attempt_count = opts[:attempt_count]
+          @user_agent = opts[:user_agent]
+          if opts[:final_error_retryable]
+            @max_retries_exceeded = 1
+          else
+            @max_retries_exceeded = 0
+          end
+          @final_http_status_code = opts[:final_http_status_code]
+          @final_aws_exception = opts[:final_aws_exception]
+          @final_aws_exception_message = opts[:final_aws_exception_message]
+          @final_sdk_exception = opts[:final_sdk_exception]
+          @final_sdk_exception_message = opts[:final_sdk_exception_message]
+          @region = opts[:region] if opts[:region] # in case region changes
+        end
+
+        def to_json(*a)
+          document = {
+            "Type" => "ApiCall",
+            "Service" => @service,
+            "Api" => @api,
+            "ClientId" => @client_id,
+            "Timestamp" => @timestamp,
+            "Version" => @version,
+            "AttemptCount" => @attempt_count,
+            "Latency" => @latency,
+            "Region" => @region,
+            "MaxRetriesExceeded" => @max_retries_exceeded,
+            "UserAgent" => @user_agent,
+            "FinalHttpStatusCode" => @final_http_status_code,
+          }
+          document["FinalSdkException"] = @final_sdk_exception if @final_sdk_exception
+          document["FinalSdkExceptionMessage"] = @final_sdk_exception_message if @final_sdk_exception_message
+          document["FinalAwsException"] = @final_aws_exception if @final_aws_exception
+          document["FinalAwsExceptionMessage"] = @final_aws_exception_message if @final_aws_exception_message
+          document = _truncate(document)
+          document.to_json
+        end
+
+        private
+        def _truncate(document)
+          document.each do |key, value|
+            limit = FIELD_MAX_LENGTH[key]
+            if limit && value.to_s.length > limit
+              document[key] = value.to_s.slice(0...limit)
+            end
+          end
+          document
+        end
+      end
+
+      class ApiCallAttempt
+        attr_reader :service, :api, :client_id, :version, :timestamp,
+          :user_agent, :access_key, :session_token
+        attr_accessor :region, :fqdn, :request_latency, :http_status_code,
+          :aws_exception_msg, :x_amz_request_id, :x_amz_id_2,
+          :x_amzn_request_id, :sdk_exception, :aws_exception, :sdk_exception_msg
+
+        def initialize(
+          service,
+          api,
+          client_id,
+          version,
+          timestamp,
+          fqdn,
+          region,
+          user_agent,
+          access_key,
+          session_token
+        )
+          @service = service
+          @api = api
+          @client_id = client_id
+          @version = version
+          @timestamp = timestamp
+          @fqdn = fqdn
+          @region = region
+          @user_agent = user_agent
+          @access_key = access_key
+          @session_token = session_token
+        end
+
+        def to_json(*a)
+          json = {
+            "Type" => "ApiCallAttempt",
+            "Service" => @service,
+            "Api" => @api,
+            "ClientId" => @client_id,
+            "Timestamp" => @timestamp,
+            "Version" => @version,
+            "Fqdn" => @fqdn,
+            "Region" => @region,
+            "UserAgent" => @user_agent,
+            "AccessKey" => @access_key
+          }
+          # Optional Fields
+          json["SessionToken"] = @session_token if @session_token
+          json["HttpStatusCode"] = @http_status_code if @http_status_code
+          json["AwsException"] = @aws_exception if @aws_exception
+          json["AwsExceptionMessage"] = @aws_exception_msg if @aws_exception_msg
+          json["XAmznRequestId"] = @x_amzn_request_id if @x_amzn_request_id
+          json["XAmzRequestId"] = @x_amz_request_id if @x_amz_request_id
+          json["XAmzId2"] = @x_amz_id_2 if @x_amz_id_2
+          json["AttemptLatency"] = @request_latency if @request_latency
+          json["SdkException"] = @sdk_exception if @sdk_exception
+          json["SdkExceptionMessage"] = @sdk_exception_msg if @sdk_exception_msg
+          json = _truncate(json)
+          json.to_json
+        end
+
+        private
+        def _truncate(document)
+          document.each do |key, value|
+            limit = FIELD_MAX_LENGTH[key]
+            if limit && value.to_s.length > limit
+              document[key] = value.to_s.slice(0...limit)
+            end
+          end
+          document
+        end
+      end
+
+    end
+  end
+end