aws-sdk-core 3.191.1 → 3.229.0

data/lib/aws-sdk-core/cbor/encoder.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Aws
+  module Cbor
+    # Pure ruby implementation of CBOR encoder.
+    class Encoder
+      def initialize
+        @buffer = String.new
+      end
+
+      # @return the encoded bytes in CBOR format for all added data
+      def bytes
+        @buffer
+      end
+
+      # generic method for adding generic Ruby data based on its type
+      def add(value)
+        case value
+        when BigDecimal then add_big_decimal(value)
+        when Integer then add_auto_integer(value)
+        when Numeric then add_auto_float(value)
+        when Symbol then add_string(value.to_s)
+        when true, false then add_boolean(value)
+        when nil then add_nil
+        when Tagged
+          add_tag(value.tag)
+          add(value.value)
+        when String
+          if value.encoding == Encoding::BINARY
+            add_byte_string(value)
+          else
+            add_string(value)
+          end
+        when Array
+          start_array(value.size)
+          value.each { |di| add(di) }
+        when Hash
+          start_map(value.size)
+          value.each do |k, v|
+            add(k)
+            add(v)
+          end
+        when Time
+          add_time(value)
+        else
+          raise UnknownTypeError, value
+        end
+        self
+      end
+
+      private
+
+      MAJOR_TYPE_UNSIGNED_INT = 0x00 # 000_00000 - Major Type 0 - unsigned int
+      MAJOR_TYPE_NEGATIVE_INT = 0x20 # 001_00000 - Major Type 1 - negative int
+      MAJOR_TYPE_BYTE_STR = 0x40 # 010_00000 - Major Type 2 (Byte String)
+      MAJOR_TYPE_STR = 0x60 # 011_00000 - Major Type 3 (Text String)
+      MAJOR_TYPE_ARRAY = 0x80 # 100_00000 - Major Type 4 (Array)
+      MAJOR_TYPE_MAP = 0xa0 # 101_00000 - Major Type 5 (Map)
+      MAJOR_TYPE_TAG = 0xc0 # 110_00000 - Major type 6 (Tag)
+      MAJOR_TYPE_SIMPLE = 0xe0 # 111_00000 - Major type 7 (111) + 5 bit 0
+
+      FLOAT_BYTES = 0xfa # 111_11010 - Major type 7 (Float) + value: 26
+      DOUBLE_BYTES = 0xfb # 111_ 11011 - Major type 7 (Float) + value: 26
+
+      # https://www.rfc-editor.org/rfc/rfc8949.html#tags
+      TAG_TYPE_EPOCH = 1
+      TAG_BIGNUM_BASE = 2
+      TAG_TYPE_BIGDEC = 4
+
+      MAX_INTEGER = 18_446_744_073_709_551_616 # 2^64
+
+      def head(major_type, value)
+        @buffer <<
+          case value
+          when 0...24
+            [major_type + value].pack('C') # 8-bit unsigned
+          when 0...256
+            [major_type + 24, value].pack('CC')
+          when 0...65_536
+            [major_type + 25, value].pack('Cn')
+          when 0...4_294_967_296
+            [major_type + 26, value].pack('CN')
+          when 0...MAX_INTEGER
+            [major_type + 27, value].pack('CQ>')
+          else
+            raise Error, "Value is too large to encode: #{value}"
+          end
+      end
+
+      # streaming style, lower level interface
+      def add_integer(value)
+        major_type =
+          if value.negative?
+            value = -1 - value
+            MAJOR_TYPE_NEGATIVE_INT
+          else
+            MAJOR_TYPE_UNSIGNED_INT
+          end
+        head(major_type, value)
+      end
+
+      def add_bignum(value)
+        major_type =
+          if value.negative?
+            value = -1 - value
+            MAJOR_TYPE_NEGATIVE_INT
+          else
+            MAJOR_TYPE_UNSIGNED_INT
+          end
+        s = bignum_to_bytes(value)
+        head(MAJOR_TYPE_TAG, TAG_BIGNUM_BASE + (major_type >> 5))
+        head(MAJOR_TYPE_BYTE_STR, s.bytesize)
+        @buffer << s
+      end
+
+      # A decimal fraction or a bigfloat is represented as a tagged array
+      # that contains exactly two integer numbers:
+      # an exponent e and a mantissa m
+      # decimal fractions are always represented with a base of 10
+      # See: https://www.rfc-editor.org/rfc/rfc8949.html#name-decimal-fractions-and-bigfl
+      def add_big_decimal(value)
+        if value.infinite? == 1
+          return add_float(value.infinite? * Float::INFINITY)
+        elsif value.nan?
+          return add_float(Float::NAN)
+        end
+
+        head(MAJOR_TYPE_TAG, TAG_TYPE_BIGDEC)
+        sign, digits, base, exp = value.split
+        # Ruby BigDecimal digits of XXX are used as 0.XXX, convert
+        exp = exp - digits.size
+        digits = sign * digits.to_i
+        start_array(2)
+        add_auto_integer(exp)
+        add_auto_integer(digits)
+      end
+
+      def add_auto_integer(value)
+        major_type =
+          if value.negative?
+            value = -1 - value
+            MAJOR_TYPE_NEGATIVE_INT
+          else
+            MAJOR_TYPE_UNSIGNED_INT
+          end
+
+        if value >= MAX_INTEGER
+          s = bignum_to_bytes(value)
+          head(MAJOR_TYPE_TAG, TAG_BIGNUM_BASE + (major_type >> 5))
+          head(MAJOR_TYPE_BYTE_STR, s.bytesize)
+          @buffer << s
+        else
+          head(major_type, value)
+        end
+      end
+
+      def add_float(value)
+        @buffer << [FLOAT_BYTES, value].pack('Cg') # single-precision
+      end
+
+      def add_double(value)
+        @buffer << [DOUBLE_BYTES, value].pack('CG') # double-precision
+      end
+
+      def add_auto_float(value)
+        if value.nan?
+          @buffer << FLOAT_BYTES << [value].pack('g')
+        else
+          ss = [value].pack('g') # single-precision
+          if ss.unpack1('g') == value
+            @buffer << FLOAT_BYTES << ss
+          else
+            @buffer << [DOUBLE_BYTES, value].pack('CG') # double-precision
+          end
+        end
+      end
+
+      def add_nil
+        head(MAJOR_TYPE_SIMPLE, 22)
+      end
+
+      def add_boolean(value)
+        value ? head(MAJOR_TYPE_SIMPLE, 21) : head(MAJOR_TYPE_SIMPLE, 20)
+      end
+
+      # Encoding MUST already be Encoding::BINARY
+      def add_byte_string(value)
+        head(MAJOR_TYPE_BYTE_STR, value.bytesize)
+        @buffer << value
+      end
+
+      def add_string(value)
+        value = value.encode(Encoding::UTF_8).force_encoding(Encoding::BINARY)
+        head(MAJOR_TYPE_STR, value.bytesize)
+        @buffer << value
+      end
+
+      # caller is responsible for adding length values
+      def start_array(length)
+        head(MAJOR_TYPE_ARRAY, length)
+      end
+
+      def start_indefinite_array
+        head(MAJOR_TYPE_ARRAY + 31, 0)
+      end
+
+      # caller is responsible for adding length key/value pairs
+      def start_map(length)
+        head(MAJOR_TYPE_MAP, length)
+      end
+
+      def start_indefinite_map
+        head(MAJOR_TYPE_MAP + 31, 0)
+      end
+
+      def end_indefinite_collection
+        # write the stop sequence
+        head(MAJOR_TYPE_SIMPLE + 31, 0)
+      end
+
+      def add_tag(tag)
+        head(MAJOR_TYPE_TAG, tag)
+      end
+
+      def add_time(value)
+        head(MAJOR_TYPE_TAG, TAG_TYPE_EPOCH)
+        epoch = value.to_f
+        add_double(epoch)
+      end
+
+      def bignum_to_bytes(value)
+        s = String.new
+        while value != 0
+          s << (value & 0xFF)
+          value >>= 8
+        end
+        s.reverse!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'cbor/encoder'
+require_relative 'cbor/decoder'
+
+module Aws
+  # @api private
+  module Cbor
+
+    # CBOR Tagged data (Major type 6).
+    # A Tag consists of a tag number and a value.
+    # In the extended generic data model, a tag number's definition
+    # describes the additional semantics conveyed with the tag number.
+    # # @!method initialize(*args)
+    #   @option args [Integer] :tag The tag number.
+    #   @option args [Object] :value The tag's content.
+    # @!attribute tag
+    #   The tag number.
+    #   @return [Integer]
+    # @!attribute value
+    #   The tag's content.
+    #   @return [Object]
+    Tagged = Struct.new(:tag, :value)
+
+    class Error < StandardError; end
+
+    class OutOfBytesError < Error
+      def initialize(n, left)
+        super("Out of bytes. Trying to read #{n} bytes but buffer contains only #{left}")
+      end
+    end
+
+    class UnknownTypeError < Error
+      def initialize(type)
+        super("Unable to encode #{type}")
+      end
+    end
+
+    class ExtraBytesError < Error
+      def initialize(pos, size)
+        super("Extra bytes follow after decoding item. Read #{pos} / #{size} bytes")
+      end
+    end
+
+    class UnexpectedBreakCodeError < Error; end
+
+    class UnexpectedAdditionalInformationError < Error
+      def initialize(add_info)
+        super("Unexpected additional information: #{add_info}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Aws
+  # setup autoloading for ClientSideMonitoring module
+  module ClientSideMonitoring
+    autoload :RequestMetrics, 'aws-sdk-core/client_side_monitoring/request_metrics'
+    autoload :Publisher, 'aws-sdk-core/client_side_monitoring/publisher'
+  end
+end

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

@@ -15,27 +15,11 @@ module Aws
 
     # @api private
     def setup_stubbing
-      @stubs = {}
-      @stub_mutex = Mutex.new
       if Hash === @config.stub_responses
         @config.stub_responses.each do |operation_name, stubs|
           apply_stubs(operation_name, Array === stubs ? stubs : [stubs])
         end
       end
-
-      # When a client is stubbed allow the user to access the requests made
-      requests = @api_requests = []
-      requests_mutex = @requests_mutex = Mutex.new
-      self.handle do |context|
-        requests_mutex.synchronize do
-          requests << {
-            operation_name: context.operation_name,
-            params: context.params,
-            context: context
-          }
-        end
-        @handler.call(context)
-      end
     end
 
     # Configures what data / errors should be returned from the named operation
@@ -175,7 +159,7 @@ module Aws
     #   on a client that has not enabled response stubbing via
     #   `:stub_responses => true`.
     def stub_responses(operation_name, *stubs)
-      if config.stub_responses
+      if @config.stub_responses
         apply_stubs(operation_name, stubs.flatten)
       else
         msg = 'stubbing is not enabled; enable stubbing in the constructor '\
@@ -194,12 +178,12 @@ module Aws
     # @raise [NotImplementedError] Raises `NotImplementedError` when the client
     #   is not stubbed.
     def api_requests(options = {})
-      if config.stub_responses
-        @requests_mutex.synchronize do
+      if @config.stub_responses
+        @config.api_requests_mutex.synchronize do
           if options[:exclude_presign]
-            @api_requests.reject {|req| req[:context][:presigned_url] }
+            @config.api_requests.reject {|req| req[:context][:presigned_url] }
           else
-            @api_requests
+            @config.api_requests
           end
         end
       else
@@ -228,54 +212,44 @@ module Aws
     # @return [Structure] Returns a stubbed response data structure. The
     #   actual class returned will depend on the given `operation_name`.
     def stub_data(operation_name, data = {})
-      Stubbing::StubData.new(config.api.operation(operation_name)).stub(data)
+      Stubbing::StubData.new(@config.api.operation(operation_name)).stub(data)
     end
 
     # @api private
     def next_stub(context)
       operation_name = context.operation_name.to_sym
-      stub = @stub_mutex.synchronize do
-        stubs = @stubs[operation_name] || []
+      stub = @config.stubs_mutex.synchronize do
+        stubs = @config.stubs[operation_name] || []
         case stubs.length
-        when 0 then default_stub(operation_name)
+        when 0 then stub_data(operation_name)
         when 1 then stubs.first
         else stubs.shift
         end
       end
-      Proc === stub ? convert_stub(operation_name, stub.call(context)) : stub
+      stub = convert_stub(operation_name, stub, context)
+      stub[:mutex] = Mutex.new
+      stub
     end
 
     private
 
-    def default_stub(operation_name)
-      stub = stub_data(operation_name)
-      http_response_stub(operation_name, stub)
+    def apply_stubs(operation_name, stubs)
+      @config.stubs_mutex.synchronize do
+        @config.stubs[operation_name.to_sym] = stubs
+      end
     end
 
     # This method converts the given stub data and converts it to a
     # HTTP response (when possible). This enables the response stubbing
     # plugin to provide a HTTP response that triggers all normal events
     # during response handling.
-    def apply_stubs(operation_name, stubs)
-      @stub_mutex.synchronize do
-        @stubs[operation_name.to_sym] = stubs.map do |stub|
-          convert_stub(operation_name, stub)
-        end
-      end
-    end
-
-    def convert_stub(operation_name, stub)
-      stub = case stub
-      when Proc then stub
+    def convert_stub(operation_name, stub, context)
+      case stub
+      when Proc then convert_stub(operation_name, stub.call(context), context)
       when Exception, Class then { error: stub }
       when String then service_error_stub(stub)
-      when Hash then http_response_stub(operation_name, stub)
-      else { data: stub }
-      end
-      if Hash === stub
-        stub[:mutex] = Mutex.new
+      else http_response_stub(operation_name, stub)
       end
-      stub
     end
 
     def service_error_stub(error_code)
@@ -299,21 +273,22 @@ module Aws
     end
 
     def data_to_http_resp(operation_name, data)
-      api = config.api
+      api = @config.api
       operation = api.operation(operation_name)
       ParamValidator.new(operation.output, input: false).validate!(data)
       protocol_helper.stub_data(api, operation, data)
     end
 
     def protocol_helper
-      case config.api.metadata['protocol']
-      when 'json'        then Stubbing::Protocols::Json
-      when 'query'       then Stubbing::Protocols::Query
-      when 'ec2'         then Stubbing::Protocols::EC2
-      when 'rest-json'   then Stubbing::Protocols::RestJson
-      when 'rest-xml'    then Stubbing::Protocols::RestXml
-      when 'api-gateway' then Stubbing::Protocols::ApiGateway
-      else raise "unsupported protocol"
+      case @config.api.metadata['protocol']
+      when 'json'               then Stubbing::Protocols::Json
+      when 'rest-json'          then Stubbing::Protocols::RestJson
+      when 'rest-xml'           then Stubbing::Protocols::RestXml
+      when 'query'              then Stubbing::Protocols::Query
+      when 'ec2'                then Stubbing::Protocols::EC2
+      when 'smithy-rpc-v2-cbor' then Stubbing::Protocols::RpcV2
+      when 'api-gateway'        then Stubbing::Protocols::ApiGateway
+      else raise 'unsupported protocol'
       end.new
     end
   end

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

@@ -9,6 +9,10 @@ module Aws
     # @return [Time]
     attr_reader :expiration
 
+    # @api private
+    # Returns UserAgent metrics for credentials.
+    attr_accessor :metrics
+
     # @return [Boolean]
     def set?
       !!@credentials && @credentials.set?

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

@@ -42,11 +42,14 @@ module Aws
 
     def static_credentials(options)
       if options[:config]
-        Credentials.new(
+        creds = Credentials.new(
           options[:config].access_key_id,
           options[:config].secret_access_key,
-          options[:config].session_token
+          options[:config].session_token,
+          account_id: options[:config].account_id
         )
+        creds.metrics = ['CREDENTIALS_PROFILE']
+        creds
       end
     end
 
@@ -75,7 +78,9 @@ module Aws
 
     def static_profile_credentials(options)
       if options[:config] && options[:config].profile
-        SharedCredentials.new(profile_name: options[:config].profile)
+        creds = SharedCredentials.new(profile_name: options[:config].profile)
+        creds.metrics = ['CREDENTIALS_PROFILE']
+        creds
       end
     rescue Errors::NoSuchProfileError
       nil
@@ -84,7 +89,11 @@ module Aws
     def static_profile_process_credentials(options)
       if Aws.shared_config.config_enabled? && options[:config] && options[:config].profile
         process_provider = Aws.shared_config.credential_process(profile: options[:config].profile)
-        ProcessCredentials.new(process_provider) if process_provider
+        if process_provider
+          creds = ProcessCredentials.new([process_provider])
+          creds.metrics << 'CREDENTIALS_PROFILE_PROCESS'
+          creds
+        end
       end
     rescue Errors::NoSuchProfileError
       nil
@@ -94,7 +103,15 @@ module Aws
       key =    %w[AWS_ACCESS_KEY_ID AMAZON_ACCESS_KEY_ID AWS_ACCESS_KEY]
       secret = %w[AWS_SECRET_ACCESS_KEY AMAZON_SECRET_ACCESS_KEY AWS_SECRET_KEY]
       token =  %w[AWS_SESSION_TOKEN AMAZON_SESSION_TOKEN]
-      Credentials.new(envar(key), envar(secret), envar(token))
+      account_id = %w[AWS_ACCOUNT_ID]
+      creds = Credentials.new(
+        envar(key),
+        envar(secret),
+        envar(token),
+        account_id: envar(account_id)
+      )
+      creds.metrics = ['CREDENTIALS_ENV_VARS']
+      creds
     end
 
     def envar(keys)
@@ -110,16 +127,22 @@ module Aws
 
     def shared_credentials(options)
       profile_name = determine_profile_name(options)
-      SharedCredentials.new(profile_name: profile_name)
+      creds = SharedCredentials.new(profile_name: profile_name)
+      creds.metrics = ['CREDENTIALS_PROFILE']
+      creds
     rescue Errors::NoSuchProfileError
       nil
     end
 
     def process_credentials(options)
       profile_name = determine_profile_name(options)
-      if Aws.shared_config.config_enabled? &&
-         (process_provider = Aws.shared_config.credential_process(profile: profile_name))
-        ProcessCredentials.new(process_provider)
+      if Aws.shared_config.config_enabled?
+        process_provider = Aws.shared_config.credential_process(profile: profile_name)
+        if process_provider
+          creds = ProcessCredentials.new([process_provider])
+          creds.metrics << 'CREDENTIALS_PROFILE_PROCESS'
+          creds
+        end
       end
     rescue Errors::NoSuchProfileError
       nil
@@ -149,7 +172,11 @@ module Aws
           role_session_name: ENV['AWS_ROLE_SESSION_NAME']
         }
         cfg[:region] = region if region
-        AssumeRoleWebIdentityCredentials.new(cfg)
+        Aws::Plugins::UserAgent.metric('CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN') do
+          creds = AssumeRoleWebIdentityCredentials.new(cfg)
+          creds.metrics << 'CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN'
+          creds
+        end
       elsif Aws.shared_config.config_enabled?
         profile = options[:config].profile if options[:config]
         Aws.shared_config.assume_role_web_identity_credentials_from_config(
@@ -164,7 +191,7 @@ module Aws
       if ENV['AWS_CONTAINER_CREDENTIALS_RELATIVE_URI'] ||
          ENV['AWS_CONTAINER_CREDENTIALS_FULL_URI']
         ECSCredentials.new(options)
-      else
+      elsif !(ENV.fetch('AWS_EC2_METADATA_DISABLED', 'false').downcase == 'true')
         InstanceProfileCredentials.new(options.merge(profile: profile_name))
       end
     end

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

@@ -6,21 +6,34 @@ module Aws
     # @param [String] access_key_id
     # @param [String] secret_access_key
     # @param [String] session_token (nil)
-    def initialize(access_key_id, secret_access_key, session_token = nil)
+    # @param [Hash] kwargs
+    # @option kwargs [String] :credential_scope (nil)
+    def initialize(access_key_id, secret_access_key, session_token = nil,
+                   **kwargs)
       @access_key_id = access_key_id
       @secret_access_key = secret_access_key
       @session_token = session_token
+      @account_id = kwargs[:account_id]
+      @metrics = ['CREDENTIALS_CODE']
     end
 
-    # @return [String, nil]
+    # @return [String]
     attr_reader :access_key_id
 
-    # @return [String, nil]
+    # @return [String]
     attr_reader :secret_access_key
 
     # @return [String, nil]
     attr_reader :session_token
 
+    # @return [String, nil]
+    attr_reader :account_id
+
+    # @api private
+    # Returns the credentials source. Used for tracking credentials
+    # related UserAgent metrics.
+    attr_accessor :metrics
+
     # @return [Credentials]
     def credentials
       self
@@ -30,9 +43,9 @@ module Aws
     #   access key are both set.
     def set?
       !access_key_id.nil? &&
-      !access_key_id.empty? &&
-      !secret_access_key.nil? &&
-      !secret_access_key.empty?
+        !access_key_id.empty? &&
+        !secret_access_key.nil? &&
+        !secret_access_key.empty?
     end
 
     # Removing the secret access key from the default inspect string.

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

@@ -183,7 +183,7 @@ module Aws
 
     def open_connection
       uri = URI.parse(@endpoint)
-      http = Net::HTTP.new(uri.hostname || @endpoint, @port || uri.port)
+      http = Net::HTTP.new(uri.hostname || @endpoint, uri.port || @port)
       http.open_timeout = @http_open_timeout
       http.read_timeout = @http_read_timeout
       http.set_debug_output(@http_debug_output) if @http_debug_output

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

@@ -77,6 +77,7 @@ module Aws
       @http_debug_output = options[:http_debug_output]
       @backoff = backoff(options[:backoff])
       @async_refresh = false
+      @metrics = ['CREDENTIALS_HTTP']
       super
     end
 

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

@@ -3,15 +3,17 @@
 module Aws
   module Endpoints
     class Endpoint
-      def initialize(url:, properties: {}, headers: {})
+      def initialize(url:, properties: {}, headers: {}, metadata: {})
         @url = url
         @properties = properties
         @headers = headers
+        @metadata = metadata
       end
 
       attr_reader :url
       attr_reader :properties
       attr_reader :headers
+      attr_reader :metadata
     end
   end
 end