gooddata 2.3.1-java → 2.3.3-java

data/lib/gooddata/cloud_resources/mssql/mssql_client.rb

@@ -49,6 +49,7 @@ module GoodData
           raise('Missing connection info for MSSQL client')
         end
 
+        # When update driver class then also updating driver class using in connection(..) method below
         Java.com.microsoft.sqlserver.jdbc.SQLServerDriver
       end
 
@@ -90,7 +91,7 @@ module GoodData
         prop.setProperty('userName', authentication['userName'])
         prop.setProperty('password', authentication['password'])
 
-        @connection = java.sql.DriverManager.getConnection(connection_string, prop)
+        @connection = com.microsoft.sqlserver.jdbc.SQLServerDriver.new.connect(connection_string, prop)
       end
 
       def validate

data/lib/gooddata/cloud_resources/mysql/mysql_client.rb

@@ -49,6 +49,7 @@ module GoodData
           raise('Missing connection info for Mysql client')
         end
 
+        # When update driver class then also updating driver class using in connection(..) method below
         Java.com.mysql.jdbc.Driver
       end
 
@@ -84,7 +85,7 @@ module GoodData
         prop = java.util.Properties.new
         prop.setProperty('user', @authentication['basic']['userName'])
         prop.setProperty('password', @authentication['basic']['password'])
-        @connection = java.sql.DriverManager.getConnection(@url, prop)
+        @connection = com.mysql.jdbc.Driver.new.connect(@url, prop)
         @connection.set_auto_commit(false)
       end
 

data/lib/gooddata/cloud_resources/postgresql/postgresql_client.rb

@@ -49,6 +49,7 @@ module GoodData
           raise('Missing connection info for Postgres client')
         end
 
+        # When update driver class then also updating driver class using in connection(..) method below
         Java.org.postgresql.Driver
       end
 
@@ -86,7 +87,7 @@ module GoodData
         prop.setProperty('password', @authentication['basic']['password'])
         prop.setProperty('schema', @schema)
 
-        @connection = java.sql.DriverManager.getConnection(@url, prop)
+        @connection = org.postgresql.Driver.new.connect(@url, prop)
         statement = @connection.create_statement
         statement.execute("#{POSTGRES_SET_SCHEMA_COMMAND} #{@schema}")
         @connection.set_auto_commit(false)

data/lib/gooddata/cloud_resources/redshift/redshift_client.rb

@@ -38,6 +38,7 @@ module GoodData
         end
         @debug = options['debug'] == true || options['debug'] == 'true'
 
+        # When update driver class then also updating driver class using in connection(..) method below
         Java.com.amazon.redshift.jdbc42.Driver
       end
 
@@ -83,7 +84,7 @@ module GoodData
           prop.setProperty('DbUser', @authentication['iam']['dbUser'])
         end
 
-        @connection = java.sql.DriverManager.getConnection(full_url, prop)
+        @connection = com.amazon.redshift.jdbc42.Driver.new.connect(full_url, prop)
       end
 
       private

data/lib/gooddata/cloud_resources/snowflake/snowflake_client.rb

@@ -15,6 +15,14 @@ Dir.glob(base + 'drivers/*.jar').each do |file|
   require file unless file.start_with?('lcm-snowflake-driver')
 end
 
+java_import 'java.io.StringReader'
+java_import 'org.bouncycastle.openssl.PEMParser'
+java_import 'org.bouncycastle.jce.provider.BouncyCastleProvider'
+java_import 'org.bouncycastle.asn1.pkcs.PrivateKeyInfo'
+java_import 'org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo'
+java_import 'org.bouncycastle.openssl.jcajce.JceOpenSSLPKCS8DecryptorProviderBuilder'
+java_import 'org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter'
+
 module GoodData
   module CloudResources
     class SnowflakeClient < CloudResourceClient
@@ -41,6 +49,7 @@ module GoodData
 
         end
 
+        # When update driver class then also updating driver class using in connection(..) method below
         Java.net.snowflake.client.jdbc.SnowflakeDriver
       end
 
@@ -74,13 +83,23 @@ module GoodData
         GoodData.logger.info "Setting up connection to Snowflake #{@url}"
 
         prop = java.util.Properties.new
-        prop.setProperty('user', @authentication['basic']['userName'])
-        prop.setProperty('password', @authentication['basic']['password'])
         prop.setProperty('schema', @schema)
         prop.setProperty('warehouse', @warehouse)
         prop.setProperty('db', @database)
 
-        @connection = java.sql.DriverManager.getConnection(@url, prop)
+        if @authentication['keyPair']
+          prop.setProperty('user', @authentication['keyPair']['userName'])
+          private_key_str = build_private_key(@authentication['keyPair']['privateKey'], @authentication['keyPair']['passPhrase'])
+          prop.setProperty('private_key_base64', private_key_str)
+        else
+          prop.setProperty('user', @authentication['basic']['userName'])
+          prop.setProperty('password', @authentication['basic']['password'])
+        end
+
+        # Add JDBC_QUERY_RESULT_FORMAT parameter to fix unsafe memory issue of Snowflake JDBC driver
+        prop.setProperty('JDBC_QUERY_RESULT_FORMAT', 'JSON')
+
+        @connection = com.snowflake.client.jdbc.SnowflakeDriver.new.connect(@url, prop)
       end
 
       def build_url(url)
@@ -96,6 +115,42 @@ module GoodData
 
         url
       end
+
+      private
+
+      def build_private_key(private_key_string, pass_phrase)
+        java.security.Security.removeProvider("BC")
+        java.security.Security.addProvider(BouncyCastleProvider.new)
+
+        begin
+          pem_parser = PEMParser.new(StringReader.new(private_key_string))
+          pem_object = pem_parser.readObject
+
+          if pem_object.is_a?(PKCS8EncryptedPrivateKeyInfo)
+            builder = JceOpenSSLPKCS8DecryptorProviderBuilder.new
+            decryptor = builder.build(pass_phrase.to_java.to_char_array)
+            private_key_info = pem_object.decryptPrivateKeyInfo(decryptor)
+          elsif pem_object.is_a?(PrivateKeyInfo)
+            private_key_info = pem_object
+          end
+
+        ensure
+          pem_parser&.close
+        end
+
+        converter = JcaPEMKeyConverter.new
+        private_key = converter.getPrivateKey(private_key_info)
+        pem_str = convert_private_key(private_key)
+        java.util.Base64.getEncoder.encodeToString(pem_str.encode('UTF-8').bytes)
+      end
+
+      def convert_private_key(private_key)
+        pem = "-----BEGIN PRIVATE KEY-----\n"
+        encoder = java.util.Base64.getMimeEncoder(64, "\n".to_java_bytes)
+        base64 = encoder.encodeToString(private_key.getEncoded)
+        "#{pem}#{base64}\n-----END PRIVATE KEY-----"
+      end
+
     end
   end
 end

data/lib/gooddata/helpers/global_helpers.rb

@@ -33,7 +33,7 @@ module GoodData
       include Hashie::Extensions::DeepMerge
     end
 
-    set_const :GD_MAX_RETRY, (ENV['GD_MAX_RETRY'] && ENV['GD_MAX_RETRY'].to_i) || 12
+    set_const :GD_MAX_RETRY, (ENV['GD_MAX_RETRY'] && ENV['GD_MAX_RETRY'].to_i) || 14
     AES_256_CBC_CIPHER = 'aes-256-cbc'
 
     class << self

data/lib/gooddata/lcm/actions/import_object_collections.rb

@@ -20,28 +20,35 @@ module GoodData
 
         description 'Synchronization Info'
         param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+
+        description 'Number Of Threads'
+        param :number_of_threads, instance_of(Type::StringType), required: false, default: '10'
       end
 
       class << self
         def call(params)
           results = []
 
+          GoodData.logger.info 'Starting ImportObjectCollections action'
           client = params.gdc_gd_client
           development_client = params.development_client
+          number_of_threads = Integer(params.number_of_threads || '8')
 
-          params.synchronize.peach do |info|
+          params.synchronize.peach(number_of_threads) do |info|
             from = info.from
             to_projects = info.to
             transfer_uris = info.transfer_uris
 
             from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
 
-            to_projects.peach do |entry|
+            to_projects.peach(number_of_threads) do |entry|
               pid = entry[:pid]
               to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
 
               if transfer_uris.any?
+                logging_data(from, pid, transfer_uris, true)
                 from_project.partial_md_export(transfer_uris, project: to_project)
+                logging_data(from, pid, transfer_uris, false)
               end
 
               results << {
@@ -54,6 +61,20 @@ module GoodData
 
           results
         end
+
+        private
+
+        def logging_data(from_project, to_project, transfer_uris, start_action)
+          if start_action
+            # Logging to execution log
+            GoodData.logger.info "Starting import objects, from_project: #{from_project}, to_project: #{to_project}"
+            # Logging to Splunk log
+            GoodData.gd_logger.info "Starting import objects, action=objects_import, from_project=#{from_project}, to_project=#{to_project}, transfer_uris=#{transfer_uris}"
+          else
+            GoodData.logger.info "Success import objects, from_project: #{from_project}, to_project: #{to_project}"
+            GoodData.gd_logger.info "Success import objects, action=objects_import, from_project=#{from_project}, to_project=#{to_project}"
+          end
+        end
       end
     end
   end

data/lib/gooddata/lcm/actions/synchronize_clients.rb

@@ -50,6 +50,9 @@ module GoodData
 
         description 'Sync failed list'
         param :sync_failed_list, instance_of(Type::HashType), required: false
+
+        description 'Synchronize clients time limit'
+        param :sync_clients_timeout, instance_of(Type::StringType), required: false
       end
 
       RESULT_HEADER = [
@@ -61,6 +64,7 @@ module GoodData
 
       class << self
         def call(params)
+          GoodData.logger.info 'Starting SynchronizeClients action'
           client = params.gdc_gd_client
 
           domain_name = params.organization || params.domain
@@ -69,6 +73,8 @@ module GoodData
           data_product = params.data_product
           domain_segments = domain.segments(:all, data_product)
           keep_only_previous_masters_count = Integer(params.keep_only_previous_masters_count || "-1")
+          sync_clients_options = {}
+          sync_clients_options = sync_clients_options.merge(:time_limit => Integer(params.sync_clients_timeout)) if params.sync_clients_timeout
 
           segments = params.segments.map do |seg|
             domain_segments.find do |s|
@@ -91,7 +97,9 @@ module GoodData
             segment.master_project = master
             segment.save
 
-            res = segment.synchronize_clients
+            GoodData.logger.info "Starting synchronize clients for segment: '#{segment.segment_id}' with master workspace: '#{current_master[:master_project_id]}'"
+            res = segment.synchronize_clients(sync_clients_options)
+            GoodData.logger.info "Finish synchronize clients for segment: '#{segment.segment_id}'"
 
             sync_result = res.json['synchronizationResult']
             failed_count = sync_result['failedClients']['count']
@@ -170,7 +178,27 @@ module GoodData
 
           # Synchronize failure for all clients in segment
           if continue_on_error && success_count.zero? && failed_count.positive?
-            segment_warning_message = "Failed to synchronize clients for #{segment.segment_id} segment. Details: #{sync_result['links']['details']}"
+            segment_warning_message = "Failed to synchronize all clients for #{segment.segment_id} segment. Details: #{sync_result['links']['details']}"
+            if sync_result['links'] && sync_result['links']['details'] # rubocop:disable Style/SafeNavigation
+              begin
+                client = params.gdc_gd_client
+                response = client.get sync_result['links']['details']
+                error_detail_result = response['synchronizationResultDetails']
+
+                if error_detail_result && error_detail_result['items'] # rubocop:disable Style/SafeNavigation
+                  error_count = 1
+                  error_detail_result['items'].each do |item|
+                    break if error_count > 5
+
+                    GoodData.logger.warn(error_message(item, segment))
+                    error_count += 1
+                  end
+                end
+              rescue StandardError => ex
+                GoodData.logger.warn "Failed to fetch result of synchronize clients. Error: #{ex.message}"
+              end
+            end
+
             add_failed_segment(segment.segment_id, segment_warning_message, short_name, params)
             return
           end
@@ -192,7 +220,7 @@ module GoodData
 
         def error_message(error_item, segment)
           error_client_id = error_item['id']
-          error_message = "Failed to synchronize #{error_client_id} client in #{segment.segment_id} segment."
+          error_message = "Failed to synchronize #{error_client_id} client in #{segment.segment_id} segment"
           error_message = "#{error_message}. Detail: #{error_item['error']['message']}" if error_item['error'] && error_item['error']['message']
 
           error_message = "#{error_message}. Error items: #{error_item['error']['parameters']}" if error_item['error'] && error_item['error']['parameters']

data/lib/gooddata/lcm/actions/synchronize_dataset_mappings.rb

@@ -33,6 +33,9 @@ module GoodData
 
         description 'Sync failed list'
         param :sync_failed_list, instance_of(Type::HashType), required: false
+
+        description 'Number Of Threads'
+        param :number_of_threads, instance_of(Type::StringType), required: false, default: '10'
       end
 
       RESULT_HEADER = %i[from to count status]
@@ -45,8 +48,9 @@ module GoodData
 
           client = params.gdc_gd_client
           development_client = params.development_client
+          number_of_threads = Integer(params.number_of_threads || '8')
 
-          params.synchronize.peach do |info|
+          params.synchronize.peach(number_of_threads) do |info|
             from_project = info.from
             to_projects = info.to
 
@@ -60,7 +64,7 @@ module GoodData
             if dataset_mapping&.dig('datasetMappings', 'items').nil? || dataset_mapping['datasetMappings']['items'].empty?
               params.gdc_logger.info "Project: '#{from.title}', PID: '#{from.pid}' has no model mapping, skip synchronizing model mapping."
             else
-              to_projects.peach do |to|
+              to_projects.peach(number_of_threads) do |to|
                 pid = to[:pid]
                 next if sync_failed_project(pid, params)
 

data/lib/gooddata/lcm/actions/synchronize_etls_in_segment.rb

@@ -179,10 +179,10 @@ module GoodData
                 hidden_params_for_this_client_schedule_name = hidden_params_for_this_client[schedule_name]
 
                 schedule.update_params(schedule_additional_params) if schedule_additional_params
-                schedule.update_params(**params_for_all_schedules_in_all_projects) if params_for_all_schedules_in_all_projects
-                schedule.update_params(**params_for_all_projects_schedule_name) if params_for_all_projects_schedule_name
+                schedule.update_params(params_for_all_schedules_in_all_projects) if params_for_all_schedules_in_all_projects
+                schedule.update_params(params_for_all_projects_schedule_name) if params_for_all_projects_schedule_name
                 schedule.update_params(params_for_all_schedules_in_this_client) if params_for_all_schedules_in_this_client
-                schedule.update_params(**params_for_this_client_schedule_name) if params_for_this_client_schedule_name
+                schedule.update_params(params_for_this_client_schedule_name) if params_for_this_client_schedule_name
 
                 schedule.update_hidden_params(schedule_additional_hidden_params) if schedule_additional_hidden_params
                 schedule.update_hidden_params(hidden_params_for_all_schedules_in_all_projects) if hidden_params_for_all_schedules_in_all_projects

data/lib/gooddata/lcm/actions/synchronize_user_filters.rb

@@ -74,6 +74,9 @@ module GoodData
 
         description 'Makes the brick run without altering user filters'
         param :dry_run, instance_of(Type::StringType), required: false, default: false
+
+        description 'Number Of Threads'
+        param :number_of_threads, instance_of(Type::StringType), required: false, default: '10'
       end
 
       class << self
@@ -104,6 +107,7 @@ module GoodData
           symbolized_config = GoodData::Helpers.symbolize_keys(symbolized_config)
           symbolized_config[:labels] = symbolized_config[:labels].map { |l| GoodData::Helpers.symbolize_keys(l) }
           multiple_projects_column = params.multiple_projects_column
+          number_of_threads = Integer(params.number_of_threads || '10')
 
           mode = params.sync_mode
           unless MODES.include?(mode)
@@ -196,7 +200,7 @@ module GoodData
 
             unless run_params[:do_not_touch_filters_that_are_not_mentioned]
               to_be_deleted_clients = UserBricksHelper.non_working_clients(domain_clients, working_client_ids)
-              to_be_deleted_clients.peach do |c|
+              to_be_deleted_clients.peach(number_of_threads) do |c|
                 begin
                   current_project = c.project
                   users = users_by_project[c.client_id]

data/lib/gooddata/lcm/lcm2.rb

@@ -295,6 +295,10 @@ module GoodData
       end
 
       def perform(mode, params = {})
+        # Default setting for $pmap_default_thread_count = 20 in gooddata.rb file. We are going to decrease default
+        # number of threads count to 10 for LCM bricks only
+        $pmap_default_thread_count = 10 # rubocop:disable GlobalVars
+
         params = convert_params(params)
 
         GoodData.gd_logger.brick = mode

data/lib/gooddata/models/domain.rb

@@ -22,7 +22,15 @@ module GoodData
       'pt-PT' => 'Portuguese/Portugal',
       'fr-FR' => 'French',
       'de-DE' => 'German',
-      'ja-JP' => 'Japanese'
+      'ja-JP' => 'Japanese',
+      'it-IT' => 'Italian',
+      'es-419' => 'Spanish/Latin America',
+      'fr-CA' => 'French/Canada',
+      'en-GB' => 'English/UK',
+      'en-AU' => 'English/Australian',
+      'fi-FI' => 'Finnish',
+      'zh-Hant' => 'Traditional Chinese',
+      'zh-HK' => 'Cantonese'
     }
 
     class << self
@@ -276,12 +284,16 @@ to new properties (email=#{user_data[:email]}, sso_provider=#{user_data[:sso_pro
               [{ type: :successful, :action => :user_changed_in_domain, user: updated_user }]
             end
           rescue RuntimeError => e
+            error_message = e.message
+            user.delete(:password)
             if !domain_user
-              GoodData.logger.error("Failed to add user=#{user_login} to domain=#{default_domain_name}. Error: #{e.message}")
+              GoodData.logger.error("Failed to add user=#{user_login} to domain=#{default_domain_name}. Error: #{error_message}")
             else
-              GoodData.logger.error("Failed to update user=#{user_login} in domain=#{default_domain_name}. Error: #{e.message}")
+              error_message = 'Invalid user data or update new password cannot be the same as old password' if error_message == '400 Bad Request'
+
+              GoodData.logger.error("Failed to update user=#{user_login} in domain=#{default_domain_name}. Error: #{error_message}")
             end
-            [{ type: :failed, :user => user, message: e }]
+            [{ type: :failed, :user => user, message: error_message }]
           end
         end
       end

data/lib/gooddata/models/metadata/label.rb

@@ -44,14 +44,31 @@ module GoodData
     # In the case filter a specific value, because the API /validElements only filter by partial match, we need to filter again at client side for exact match.
     # @return [Array] Results
     def get_valid_elements(*args)
+      results = {}
       if args && !args.empty? && args.first[:filter]
+        # Support paging in case filter by a specific value
         params = args.first
-        params[:limit] = 100_000
-        results, = valid_elements params
-        results['validElements']['items'] = results['validElements']['items'].select do |i|
-          i['element']['title'] == params[:filter]
+        all_valid_elements = []
+        offset = 0
+        paging_limit = 10_000
+
+        loop do
+          params[:offset] = offset
+          params[:limit] = paging_limit
+          results, = valid_elements params
+          all_valid_elements += results['validElements']['items'].select do |i|
+            i['element']['title'] == params[:filter]
+          end
+
+          if results['validElements']['items'].count < paging_limit
+            results['validElements']['items'] = all_valid_elements
+            break
+          else
+            offset += paging_limit
+          end
         end
       else
+        # This case will support paging by the method which call this method eg: values(...) method
         results, = valid_elements(*args)
       end
       results

data/lib/gooddata/models/model.rb

@@ -166,7 +166,7 @@ module GoodData
 
         dir = Dir.mktmpdir
         begin
-          Zip::File.open("#{dir}/upload.zip", Zip::File::CREATE) do |zip|
+          Zip::File.open("#{dir}/upload.zip", create: true) do |zip|
             # TODO: make sure schema columns match CSV column names
             zip.get_output_stream('upload_info.json') { |f| f.puts JSON.pretty_generate(manifest) }
 

data/lib/gooddata/models/project.rb

@@ -1434,9 +1434,14 @@ module GoodData
           :crossDataCenterExport => '1'
         }
       }
-      result = client.post("#{md['maintenance']}/partialmdexport", export_payload)
+      export_uri = "/gdc/md/#{pid}/maintenance/partialmdexport"
+      GoodData.gd_logger.info("Project export action=objects_export, project_id=#{pid}, uri=#{export_uri}, export_status=start, export_objs=#{export_payload}") if GoodData.gd_logger
+
+      # Export api will take time to finish So increasing timeout during calling the api
+      result = client.post(export_uri, export_payload, :timeout => 10)
       polling_url = result['partialMDArtifact']['status']['uri']
       token = result['partialMDArtifact']['token']
+      GoodData.gd_logger.info("Project export action=objects_export, project_id=#{pid}, uri=#{polling_url}, export_status=polling") if GoodData.gd_logger
 
       polling_result = client.poll_on_response(polling_url, options) do |body|
         body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
@@ -1445,6 +1450,9 @@ module GoodData
         messages = GoodData::Helpers.interpolate_error_messages(polling_result['wTaskStatus']['messages']).join(' ')
         fail ObjectsExportError, "Exporting objects failed with messages. #{messages}"
       end
+
+      GoodData.gd_logger.info("Project export action=objects_export, project_id=#{pid}, export_status=success") if GoodData.gd_logger
+
       token
     end
 
@@ -1467,8 +1475,12 @@ module GoodData
         }
       }
 
-      result = client.post("#{md['maintenance']}/partialmdimport", import_payload)
+      import_uri = "/gdc/md/#{pid}/maintenance/partialmdimport"
+      GoodData.gd_logger.info("Project import action=objects_import, project_id=#{pid}, uri=#{import_uri}, import_status=start") if GoodData.gd_logger
+
+      result = client.post(import_uri, import_payload)
       polling_url = result['uri']
+      GoodData.gd_logger.info("Project import action=objects_import, project_id=#{pid}, uri=#{polling_url}, import_status=polling") if GoodData.gd_logger
 
       polling_result = client.poll_on_response(polling_url, options) do |body|
         body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
@@ -1478,6 +1490,9 @@ module GoodData
         messages = GoodData::Helpers.interpolate_error_messages(polling_result['wTaskStatus']['messages']).join(' ')
         fail ObjectsImportError, "Importing objects failed with messages. #{messages}"
       end
+
+      GoodData.gd_logger.info("Project import action=objects_import, project_id=#{pid}, uri=#{import_uri}, import_status=success") if GoodData.gd_logger
+
       true
     end
 

data/lib/gooddata/models/segment.rb

@@ -193,13 +193,14 @@ module GoodData
 
     # Runs async process that walks through segments and provisions projects if necessary.
     #
+    # @param options [Hash] Options
     # @return [Array] Returns array of results
-    def synchronize_clients
+    def synchronize_clients(options = {})
       sync_uri = SYNCHRONIZE_URI % [domain.obj_id, data_product.data_product_id, id]
       res = client.post sync_uri, nil
 
       # wait until the instance is created
-      res = client.poll_on_response(res['asyncTask']['links']['poll'], :sleep_interval => 1) do |r|
+      res = client.poll_on_response(res['asyncTask']['links']['poll'], options.merge(:sleep_interval => 1)) do |r|
         r['synchronizationResult'].nil?
       end
 

data/lib/gooddata/models/user_filters/user_filter_builder.rb

@@ -51,7 +51,7 @@ module GoodData
     end
 
     def self.read_file(file, options = {})
-      memo = Hash[]
+      memo = {}
       if row_based?(options)
         read_data_without_header(file, memo, options)
       else
@@ -180,7 +180,8 @@ module GoodData
 
     def self.create_lookups_cache(small_labels)
       small_labels.reduce({}) do |a, e|
-        lookup = e.values(:limit => 1_000_000).reduce({}) do |a1, e1|
+        # The validElements API allow maximum paging with 10000 items
+        lookup = e.values(:limit => 10_000).reduce({}) do |a1, e1|
           a1[e1[:value]] = e1[:uri]
           a1
         end
@@ -513,7 +514,7 @@ module GoodData
       if to_create.empty?
         create_results = []
       else
-        create_results = to_create.each_slice(100).flat_map do |batch|
+        create_results = to_create.each_slice(50).flat_map do |batch|
           batch.pmapcat do |related_uri, group|
             group.each(&:save)
             res = client.get("/gdc/md/#{project.pid}/userfilters?users=#{related_uri}")

data/lib/gooddata/rest/client.rb

@@ -25,7 +25,7 @@ module GoodData
       # Constants
       #################################
       DEFAULT_CONNECTION_IMPLEMENTATION = GoodData::Rest::Connection
-      DEFAULT_SLEEP_INTERVAL = 10
+      DEFAULT_SLEEP_INTERVAL = 10 # 10 seconds
       DEFAULT_POLL_TIME_LIMIT = 5 * 60 * 60 # 5 hours
 
       #################################
@@ -353,6 +353,11 @@ module GoodData
           end
           sleep retry_time
           retry_time *= GoodData::Rest::Connection::RETRY_TIME_COEFFICIENT
+          # Polling response will wait result from calling APIs. So don't need wait a long time for each polling
+          if retry_time > DEFAULT_SLEEP_INTERVAL
+            retry_time = DEFAULT_SLEEP_INTERVAL
+          end
+
           GoodData::Rest::Client.retryable(:tries => Helpers::GD_MAX_RETRY, :refresh_token => proc { connection.refresh_token }) do
             response = get(link, process: process)
           end