# File lib/awsbase/awsbase.rb, line 347
    def request_info_xml_simple(connection_name, lib_params, request, logger, params = {})

      connection = get_conn(connection_name, lib_params, logger)
      begin
        @last_request = request[:request]
        @last_response = nil

        response = connection.request(request)
        #       puts "response=" + response.body
#            benchblock.service.add!{ response = connection.request(request) }
        # check response for errors...
        @last_response = response
        if response.is_a?(Net::HTTPSuccess)
          @error_handler = nil
#                benchblock.xml.add! { parser.parse(response) }
#                return parser.result
          force_array = params[:force_array] || false
          # Force_array and group_tags don't work nice together so going to force array manually
          xml_simple_options = {"KeyToSymbol"=>false, 'ForceArray' => false}
          xml_simple_options["GroupTags"] = params[:group_tags] if params[:group_tags]

#                { 'GroupTags' => { 'searchpath' => 'dir' }
#                'ForceArray' => %r(_list$)
          parsed = XmlSimple.xml_in(response.body, xml_simple_options)
          # todo: we may want to consider stripping off a couple of layers when doing this, for instance:
          # <DescribeDBInstancesResponse xmlns="http://rds.amazonaws.com/admin/2009-10-16/">
          #  <DescribeDBInstancesResult>
          #    <DBInstances>
          # <DBInstance>....
          # Strip it off and only return an array or hash of <DBInstance>'s (hash by identifier).
          # would have to be able to make the RequestId available somehow though, perhaps some special array subclass which included that?
          unless force_array.is_a? Array
            force_array = []
          end
          parsed = symbolize(parsed, force_array)
#                puts 'parsed=' + parsed.inspect
          if params[:pull_out_array]
            ret = Aws::AwsResponseArray.new(parsed[:response_metadata])
            level_hash = parsed
            params[:pull_out_array].each do |x|
              level_hash = level_hash[x]
            end
            if level_hash.is_a? Hash # When there's only one
              ret << level_hash
            else # should be array
#                            puts 'level_hash=' + level_hash.inspect
              level_hash.each do |x|
                ret << x
              end
            end
          elsif params[:pull_out_single]
            # returns a single object
            ret = AwsResponseObjectHash.new(parsed[:response_metadata])
            level_hash = parsed
            params[:pull_out_single].each do |x|
              level_hash = level_hash[x]
            end
            ret.merge!(level_hash)
          else
            ret = parsed
          end
          return ret

        else
          @error_handler = AWSErrorHandler.new(self, nil, :errors_list => self.class.amazon_problems) unless @error_handler
          check_result = @error_handler.check(request)
          if check_result
            @error_handler = nil
            return check_result
          end
          request_text_data = "#{request[:server]}:#{request[:port]}#{request[:request].path}"
          raise AwsError2.new(@last_response.code, @last_request_id, request_text_data, @last_response.body)
        end
      ensure
        connection.finish if connection && lib_params[:connection_mode] == :per_request
      end

    end