gooddata 1.3.3 → 1.3.4

data/gooddata.gemspec

@@ -31,11 +31,11 @@ Gem::Specification.new do |s|
   s.homepage = 'http://github.com/gooddata/gooddata-ruby'
   s.require_paths = ['lib']
 
-  s.add_development_dependency 'bundler', "~> 1.14"
+  # s.add_development_dependency 'bundler', "~> 1.14"
   s.add_development_dependency 'license_finder', '~> 2.0'
   s.add_development_dependency 'rake', '~> 11.1'
   s.add_development_dependency 'redcarpet', '~> 3.1' if RUBY_PLATFORM != 'java'
-  s.add_development_dependency 'rspec', '~> 3.5'
+  s.add_development_dependency 'rspec', '~> 3.5.0'
   s.add_development_dependency 'rspec-expectations', '~> 3.5'
   s.add_development_dependency 'rspec_junit_formatter', '~> 0.3.0'
   s.add_development_dependency 'rubocop', '~> 0.59.1'
@@ -43,7 +43,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'webmock', '~> 2.3.1'
   s.add_development_dependency 'yard', '~> 0.9.11'
   s.add_development_dependency 'yard-rspec', '~> 0.1'
-  s.add_development_dependency 'ZenTest', '~> 4.11'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'pry-byebug', '~> 3.6' if RUBY_PLATFORM != 'java'
 
@@ -53,7 +52,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'pronto-flay', '~> 0.9.0' if RUBY_PLATFORM != 'java'
   s.add_development_dependency 'vcr'
 
-  s.add_dependency 'activesupport', '~> 4.2.9'
+  s.add_development_dependency 'sqlite3' if RUBY_PLATFORM != 'java'
+
+  s.add_dependency 'activesupport', '> 4.2.9', '< 5.2'
+
   s.add_dependency 'aws-sdk-s3', '~> 1.16'
   s.add_dependency 'docile', '~> 1.1'
   s.add_dependency 'erubis', '~> 2.7'

data/lcm.rake

@@ -3,6 +3,8 @@ require 'fileutils'
 require 'pathname'
 require 'rspec/core/rake_task'
 
+test_cases = %i[integration slow userprov load smoke]
+
 # Schema for new Bricks.
 brick_info_schema = {
   "type" => "object",
@@ -74,34 +76,20 @@ end
 
 RSpec::Core::RakeTask.new(:test)
 namespace :test do
-  desc 'Run integration tests'
-  RSpec::Core::RakeTask.new(:integration) do |t|
-    t.pattern = 'spec/lcm/integration/**/*.rb'
-  end
-
-  desc 'Run load tests'
-  RSpec::Core::RakeTask.new(:load) do |t|
-    t.pattern = 'spec/lcm/load/**/*.rb'
-  end
-
-  desc 'Run slow tests'
-  RSpec::Core::RakeTask.new(:slow) do |t|
-    t.pattern = 'spec/lcm/slow/**/*.rb'
-  end
-
-  namespace :integration do
-    desc 'Run integration tests in Docker'
-    task :docker do
-      system('docker-compose -f docker-compose.lcm.yml up --force-recreate --abort-on-container-exit --exit-code-from appstore appstore') ||
-        fail('Test execution failed!')
+  test_cases.each do |test_case|
+    desc "Run #{test_case} tests"
+    RSpec::Core::RakeTask.new(test_case) do |task|
+      task.pattern = "spec/lcm/#{test_case}/**/*.rb"
     end
   end
-  namespace :load do
-    desc 'Run load tests in Docker'
-    task :docker do
-      system('docker-compose -f docker-compose.lcm.yml run --rm appstore bundle exec rake -f lcm.rake test:load')
 
-      system(check_exit_code) || fail('Test execution failed!')
+  namespace :docker do
+    test_cases.each do |t|
+      desc "Run #{t} tests in Docker"
+      task t do
+        system("docker-compose -f docker-compose.lcm.yml run --rm appstore bundle exec rake -f lcm.rake test:#{t}") ||
+          fail('Test execution failed!')
+      end
     end
   end
 end

data/lib/gooddata.rb

@@ -22,6 +22,7 @@ require_relative 'gooddata/lcm/lcm'
 require_relative 'gooddata/lcm/lcm2'
 require_relative 'gooddata/models/models'
 require_relative 'gooddata/bricks/pipeline'
+require 'gooddata/extensions/object'
 
 # Files
 require_relative 'gooddata/app/app'
@@ -33,3 +34,6 @@ require_relative 'gooddata/version'
 # Extensions
 require_relative 'gooddata/extensions/extensions'
 require 'backports/2.1.0/array/to_h'
+
+# Helpers
+require 'gooddata/helpers/global_helpers'

data/lib/gooddata/bricks/middleware/aws_middleware.rb

@@ -13,7 +13,7 @@ module GoodData
       def call(params)
         params = params.to_hash
         if params.key?('aws_client')
-          puts 'Setting up AWS-S3 connection'
+          GoodData.logger.info('Setting up AWS-S3 connection')
           raise 'Unable to connect to AWS. Parameter "aws_client" seems to be empty' unless params['aws_client']
           raise 'Unable to connect to AWS. Parameter "access_key_id" is missing' if params['aws_client']['access_key_id'].blank?
           raise 'Unable to connect to AWS. Parameter "secret_access_key" is missing' if params['aws_client']['secret_access_key'].blank?

data/lib/gooddata/bricks/middleware/bench_middleware.rb

@@ -13,11 +13,11 @@ module GoodData
     class BenchMiddleware < Bricks::Middleware
       def call(params)
         params = params.to_hash
-        puts 'Starting timer'
+        GoodData.logger.info('Starting timer')
         result = nil
         report = Benchmark.measure { result = @app.call(params) }
-        puts 'Stopping timer'
-        pp report
+        GoodData.logger.info('Stopping timer')
+        GoodData.logger.info(report.pretty_inspect)
         result
       end
     end

data/lib/gooddata/bricks/middleware/dwh_middleware.rb

@@ -13,7 +13,7 @@ module GoodData
     # Connects to the warehouse (ADS) and enriches parameters with GoodData::Datawarehouse
     class WarehouseMiddleware < Bricks::Middleware
       def call(params)
-        if params.key?('ads_client') && (RUBY_PLATFORM == 'java')
+        if params.key?('ads_client')
           GoodData.logger.info "Setting up ADS connection to #{params['ads_client']['ads_id'] || params['ads_client']['jdbc_url']}"
           unless params['ads_client']['username'] || params['GDC_USERNAME']
             raise "ADS middleware needs username either as part of " \

data/lib/gooddata/bricks/middleware/fs_download_middleware.rb

@@ -33,7 +33,7 @@ module GoodData
             dav.verify_server = false
             dav.credentials(params['GDC_USERNAME'], params['GDC_PASSWORD'])
             dav.find(path, recursive: true, suppress_errors: true) do |item|
-              puts 'Checking: ' + item.url.to_s
+              GoodData.logger.info('Checking: ' + item.url.to_s)
               name = (item.uri - webdav_uri).to_s
               File.open(name, 'w') do |f|
                 f << item.content

data/lib/gooddata/bricks/middleware/fs_upload_middleware.rb

@@ -25,7 +25,7 @@ module GoodData
               GoodData.client.get '/gdc/account/token', dont_reauth: true
               url = GoodData.project_webdav_path
               GoodData.upload_to_project_webdav(path)
-              puts "Uploaded local file \"#{path}\" to url \"#{url + path}\""
+              GoodData.logger.info("Uploaded local file \"#{path}\" to url \"#{url + path}\"")
             end
           end
         end

data/lib/gooddata/bricks/middleware/gooddata_middleware.rb

@@ -33,10 +33,6 @@ module GoodData
         params = GoodData::Helpers.stringify_keys(params)
         # params = GoodData::Helpers.symbolize_keys(params)
 
-        # Set logger
-        logger = params['GDC_LOGGER']
-        GoodData.logger = logger
-
         # Set parallelism
         max_concurrency = params['max_concurrency'] || params['MAX_CONCURRENCY']
         if max_concurrency && max_concurrency.to_i > 0
@@ -91,14 +87,14 @@ module GoodData
         begin
           client.disconnect
         rescue
-          puts 'Tried to disconnect client. Was unsuccessful. Proceeding anyway.'
+          GoodData.logger.warn('Tried to disconnect client. Was unsuccessful. Proceeding anyway.')
         end
 
         # Try to disconnect development_client
         begin
           development_client.disconnect if development_client != client
         rescue
-          puts 'Tried to disconnect development_client. Was unsuccessful. Proceeding anyway.'
+          GoodData.logger.warn('Tried to disconnect development_client. Was unsuccessful. Proceeding anyway.')
         end
 
         returning_value
@@ -107,11 +103,11 @@ module GoodData
       class << self
         def connect(server, verify_ssl, username, password, sst_token) # rubocop:disable Metrics/ParameterLists
           if username.nil? || password.nil?
-            puts "Connecting with SST to server #{server}"
+            GoodData.logger.info("Connecting with SST to server #{server}")
             raise 'SST (SuperSecureToken) not present in params' if sst_token.nil?
             conn = GoodData.connect(sst_token: sst_token, server: server, verify_ssl: verify_ssl)
           else
-            puts "Connecting as #{username} to server #{server}"
+            GoodData.logger.info("Connecting as #{username} to server #{server}")
             conn = GoodData.connect(username, password, server: server, verify_ssl: verify_ssl)
           end
           conn.stats_on

data/lib/gooddata/bricks/middleware/logger_middleware.rb

@@ -19,20 +19,29 @@ using StringExtensions
 using NilExtensions
 
 require_relative 'base_middleware'
+require_relative 'mask_logger_decorator'
 
 module GoodData
   module Bricks
     class LoggerMiddleware < Bricks::Middleware
       def call(params)
         params = params.to_hash
-        logger = nil
         if params['GDC_LOGGING_OFF']
           logger = NilLogger.new
+        elsif params['GDC_LOG_DIRECTORY'] && params['GDC_EXECUTION_ID']
+          log_directory = params['GDC_LOG_DIRECTORY']
+          execution_id = params['GDC_EXECUTION_ID']
+          FileUtils.mkpath log_directory
+          logger = Logger.new("#{log_directory}/#{execution_id}.log")
+          logger.level = params['GDC_LOG_LEVEL'] || 'info'
+          values_to_mask = params['values_to_mask'] || []
+          logger = MaskLoggerDecorator.new(logger, values_to_mask) if values_to_mask.any?
         else
           logger = params[:GDC_LOGGER_FILE].nil? ? Logger.new(STDOUT) : Logger.new(params[:GDC_LOGGER_FILE])
           logger.level = params['GDC_LOG_LEVEL'] || 'info'
-          logger.info('Pipeline starts')
         end
+        GoodData.logger = logger
+        logger.info('Pipeline starts')
         params['GDC_LOGGER'] = logger
         GoodData.logging_http_on if params['HTTP_LOGGING'] && params['HTTP_LOGGING'].to_b
 

data/lib/gooddata/bricks/middleware/mask_logger_decorator.rb

@@ -0,0 +1,38 @@
+# Copyright (c) 2010-2018 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Bricks
+    # Logger decorator with ability to mask sensitive values
+    class MaskLoggerDecorator
+      # entry-point
+      # @param [Logger] logger logger to decorated
+      # @param [Array] values_to_mask sensitive values to be masked out from logs
+      def initialize(logger, values_to_mask = [])
+        @logger = logger
+        @values_to_mask = values_to_mask
+      end
+
+      # log methods to be decorated
+      %i[debug error fatal info unknown warn].each do |level|
+        define_method level do |message|
+          @logger.send(level, mask(message))
+        end
+      end
+
+      private
+
+      # Masks given message.
+      # @param message  [String] message to mask
+      # @return masked_message [String] masked message
+      def mask(message)
+        unless message.nil?
+          @values_to_mask.reduce(message) do |masked_message, value_to_mask|
+            masked_message.gsub(value_to_mask, "******")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/cli/cli.rb

@@ -5,7 +5,6 @@
 # LICENSE file in the root directory of this source tree.
 
 require 'gli'
-require 'pp'
 
 # Define GoodData::CLI as GLI Wrapper
 module GoodData

data/lib/gooddata/cli/commands/domain_cmd.rb

@@ -5,7 +5,6 @@
 # LICENSE file in the root directory of this source tree.
 
 require 'pathname'
-require 'pp'
 
 require_relative '../shared'
 require_relative '../../commands/domain'

data/lib/gooddata/cli/commands/project_cmd.rb

@@ -5,7 +5,6 @@
 # LICENSE file in the root directory of this source tree.
 
 require 'pathname'
-require 'pp'
 
 require_relative '../shared'
 require_relative '../../commands/project'

data/lib/gooddata/cli/hooks.rb

@@ -5,7 +5,6 @@
 # LICENSE file in the root directory of this source tree.
 
 require 'gli'
-require 'pp'
 
 require_relative '../helpers/auth_helpers'
 

data/lib/gooddata/connection.rb

@@ -46,7 +46,7 @@ module GoodData
       connection = connect(options, second_options, third_options)
       bl.call(connection)
     rescue Exception => e # rubocop:disable RescueException
-      puts e.message
+      GoodData.logger.error(e.message)
       raise e
     ensure
       disconnect

data/lib/gooddata/extensions/object.rb

@@ -13,8 +13,4 @@ class Object
     send(:remove_const, name) if const_defined?(name)
     send(:const_set, name, val)
   end
-
-  def to_b
-    false
-  end
 end

data/lib/gooddata/helpers/global_helpers.rb

@@ -37,7 +37,7 @@ module GoodData
 
     class << self
       def error(msg)
-        STDERR.puts(msg)
+        GoodData.logger.error(msg)
         exit 1
       end
 
@@ -140,7 +140,7 @@ module GoodData
 
         if full_outer
           (lookup.keys - marked_lookup.keys).each do |key|
-            puts lookup[key]
+            GoodData.logger.info(lookup[key])
             results << lookup[key].first.to_hash
           end
         end
@@ -232,7 +232,7 @@ module GoodData
 
       def decrypt(database64, key)
         if key.nil? || key.empty?
-          puts 'WARNING: No encryption key provided.'
+          GoodData.logger.warn('WARNING: No encryption key provided.')
           return 'no_key_provided'
         end
 

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

@@ -21,7 +21,7 @@ module GoodData
 
       class << self
         def say(msg)
-          puts "#{name}#say - #{msg}"
+          GoodData.logger.info("#{name}#say - #{msg}")
         end
 
         def call(params)

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

@@ -120,8 +120,9 @@ module GoodData
             dry_run: params[:dry_run].to_b,
             users_brick_input: params.users_brick_users
           }
+          all_clients = domain.clients(:all, data_product).to_a
 
-          puts "Synchronizing in mode \"#{mode}\""
+          GoodData.logger.info("Synchronizing in mode \"#{mode}\"")
           case mode
           when 'sync_project', 'sync_one_project_based_on_pid', 'sync_one_project_based_on_custom_id'
             if mode == 'sync_one_project_based_on_pid'
@@ -138,14 +139,15 @@ module GoodData
               fail "The #{multiple_projects_column} cannot be empty" if id.blank?
 
               if mode == 'sync_multiple_projects_based_on_custom_id'
-                current_project = domain.clients(id, data_product).project
+                c = all_clients.detect { |specific_client| specific_client.id == id }
+                current_project = c.project
               elsif mode == 'sync_multiple_projects_based_on_pid'
                 current_project = client.projects(id)
               end
               sync_user_filters(current_project, new_filters, run_params.merge(users_brick_input: users), symbolized_config)
             end
           when 'sync_domain_client_workspaces'
-            domain_clients = domain.clients(:all, data_product)
+            domain_clients = all_clients
             if params.segments
               segment_uris = params.segments.map(&:uri)
               domain_clients = domain_clients.select { |c| segment_uris.include?(c.segment_uri) }
@@ -159,7 +161,7 @@ module GoodData
               users = users_by_project[client_id]
               fail "Client id cannot be empty" if client_id.blank?
 
-              c = domain.clients(client_id, data_product)
+              c = all_clients.detect { |specific_client| specific_client.id == client_id }
               if params.segments && !segment_uris.include?(c.segment_uri)
                 params.gdc_logger.warn "Client #{client_id} is outside segments_filter #{params.segments}"
                 next

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

@@ -181,6 +181,14 @@ module GoodData
           #     aiming at solving the problem that the customer cannot give us the
           #     value of a project id in the data since he does not know it upfront
           #     and we cannot influence its value.
+          common_params = {
+            domain: domain, 
+            whitelists: whitelists,  
+            ignore_failures: ignore_failures,  
+            remove_users_from_project: remove_users_from_project,  
+            do_not_touch_users_that_are_not_mentioned: do_not_touch_users_that_are_not_mentioned,  
+            create_non_existing_user_groups: create_non_existing_user_groups
+          }
           results = case mode
                     when 'add_to_organization'
                       domain.create_users(new_users.uniq { |u| u[:login] || u[:email] })
@@ -190,24 +198,12 @@ module GoodData
                       params.gdc_logger.warn "Deleting #{users.count} users from domain #{domain_name}"
                       users.map(&:delete)
                     when 'sync_project'
-                      project.import_users(new_users,
-                                           domain: domain,
-                                           whitelists: whitelists,
-                                           ignore_failures: ignore_failures,
-                                           remove_users_from_project: remove_users_from_project,
-                                           do_not_touch_users_that_are_not_mentioned: do_not_touch_users_that_are_not_mentioned,
-                                           create_non_existing_user_groups: create_non_existing_user_groups)
+                      project.import_users(new_users, common_params)
                     when 'sync_multiple_projects_based_on_pid'
                       new_users.group_by { |u| u[:pid] }.flat_map do |project_id, users|
                         begin
                           project = client.projects(project_id)
-                          project.import_users(users,
-                                               domain: domain,
-                                               whitelists: whitelists,
-                                               ignore_failures: ignore_failures,
-                                               remove_users_from_project: remove_users_from_project,
-                                               do_not_touch_users_that_are_not_mentioned: do_not_touch_users_that_are_not_mentioned,
-                                               create_non_existing_user_groups: create_non_existing_user_groups)
+                          project.import_users(users, common_params)
                         rescue RestClient::ResourceNotFound
                           fail "Project \"#{project_id}\" was not found. Please check your project ids in the source file"
                         rescue RestClient::Gone
@@ -218,13 +214,7 @@ module GoodData
                       end
                     when 'sync_one_project_based_on_pid'
                       filtered_users = new_users.select { |u| u[:pid] == project.pid }
-                      project.import_users(filtered_users,
-                                           domain: domain,
-                                           whitelists: whitelists,
-                                           ignore_failures: ignore_failures,
-                                           remove_users_from_project: remove_users_from_project,
-                                           do_not_touch_users_that_are_not_mentioned: do_not_touch_users_that_are_not_mentioned,
-                                           create_non_existing_user_groups: create_non_existing_user_groups)
+                      project.import_users(filtered_users, common_params)
                     when 'sync_one_project_based_on_custom_id'
                       filter_value = UserBricksHelper.resolve_client_id(domain, project, data_product)
 
@@ -243,32 +233,21 @@ module GoodData
                         )
                       end
 
-                      puts "Project #{project.pid} will receive #{filtered_users.count} from #{new_users.count} users"
-                      project.import_users(filtered_users,
-                                           domain: domain,
-                                           whitelists: whitelists,
-                                           ignore_failures: ignore_failures,
-                                           remove_users_from_project: remove_users_from_project,
-                                           do_not_touch_users_that_are_not_mentioned: do_not_touch_users_that_are_not_mentioned,
-                                           create_non_existing_user_groups: create_non_existing_user_groups)
+                      GoodData.logger.info("Project #{project.pid} will receive #{filtered_users.count} from #{new_users.count} users")
+                      project.import_users(filtered_users, common_params)
                     when 'sync_multiple_projects_based_on_custom_id'
+                      all_clients = domain.clients(:all, data_product).to_a
                       new_users.group_by { |u| u[:pid] }.flat_map do |client_id, users|
                         fail "Client id cannot be empty" if client_id.blank?
-                        begin
-                          project = domain.clients(client_id, data_product).project
-                        rescue RestClient::BadRequest => e
-                          raise e unless /does not exist in data product/ =~ e.response
-                          fail "The client \"#{client_id}\" does not exist in data product \"#{data_product.data_product_id}\""
-                        end
+
+                        c = all_clients.detect { |specific_client| specific_client.id == client_id }
+                        fail "The client \"#{client_id}\" does not exist in data product \"#{data_product.data_product_id}\"" if c.nil?
+
+                        project = c.project
                         fail "Client #{client_id} does not have project." unless project
-                        puts "Project #{project.pid} of client #{client_id} will receive #{users.count} users"
-                        project.import_users(users,
-                                             domain: domain,
-                                             whitelists: whitelists,
-                                             ignore_failures: ignore_failures,
-                                             remove_users_from_project: remove_users_from_project,
-                                             do_not_touch_users_that_are_not_mentioned: do_not_touch_users_that_are_not_mentioned,
-                                             create_non_existing_user_groups: create_non_existing_user_groups)
+
+                        GoodData.logger.info("Project #{project.pid} of client #{client_id} will receive #{users.count} users")
+                        project.import_users(users, common_params)
                       end
                     when 'sync_domain_client_workspaces'
                       domain_clients = domain.clients(:all, data_product)
@@ -280,22 +259,18 @@ module GoodData
                       res = []
                       res += new_users.group_by { |u| u[:pid] }.flat_map do |client_id, users|
                         fail "Client id cannot be empty" if client_id.blank?
-                        c = domain.clients(client_id, data_product)
+
+                        c = domain_clients.detect { |specific_client| specific_client.id == client_id }
                         if params.segments && !segment_uris.include?(c.segment_uri)
-                          puts "Client #{client_id} is outside segments_filter #{params.segments}"
+                          GoodData.logger.info("Client #{client_id} is outside segments_filter #{params.segments}")
                           next
                         end
                         project = c.project
                         fail "Client #{client_id} does not have project." unless project
+
                         working_client_ids << client_id.to_s
-                        puts "Project #{project.pid} of client #{client_id} will receive #{users.count} users"
-                        project.import_users(users,
-                                             domain: domain,
-                                             whitelists: whitelists,
-                                             ignore_failures: ignore_failures,
-                                             remove_users_from_project: remove_users_from_project,
-                                             do_not_touch_users_that_are_not_mentioned: do_not_touch_users_that_are_not_mentioned,
-                                             create_non_existing_user_groups: create_non_existing_user_groups)
+                        GoodData.logger.info("Project #{project.pid} of client #{client_id} will receive #{users.count} users")
+                        project.import_users(users, common_params)
                       end
 
                       params.gdc_logger.debug("Working client ids are: #{working_client_ids.join(', ')}")
@@ -306,51 +281,39 @@ module GoodData
                           begin
                             project = c.project
                           rescue => e
-                            puts "Error when accessing project of client #{c.client_id}. Error: #{e}"
+                            GoodData.logger.error("Error when accessing project of client #{c.client_id}. Error: #{e}")
                             next
                           end
                           unless project
-                            puts "Client #{c.client_id} has no project."
+                            GoodData.logger.info("Client #{c.client_id} has no project.")
                             next
                           end
                           if project.deleted?
-                            puts "Project #{project.pid} of client #{c.client_id} is deleted."
+                            GoodData.logger.info("Project #{project.pid} of client #{c.client_id} is deleted.")
                             next
                           end
-                          puts "Synchronizing all users in project #{project.pid} of client #{c.client_id}"
-                          res += project.import_users([],
-                                                      domain: domain,
-                                                      whitelists: whitelists,
-                                                      ignore_failures: ignore_failures,
-                                                      remove_users_from_project: remove_users_from_project,
-                                                      do_not_touch_users_that_are_not_mentioned: do_not_touch_users_that_are_not_mentioned,
-                                                      create_non_existing_user_groups: create_non_existing_user_groups)
+                          GoodData.logger.info("Synchronizing all users in project #{project.pid} of client #{c.client_id}")
+                          res += project.import_users([], common_params)
                         end
                       end
 
                       res
                     when 'sync_domain_and_project'
                       domain.create_users(new_users, ignore_failures: ignore_failures)
-                      project.import_users(new_users,
-                                           domain: domain,
-                                           whitelists: whitelists,
-                                           ignore_failures: ignore_failures,
-                                           remove_users_from_project: remove_users_from_project,
-                                           do_not_touch_users_that_are_not_mentioned: do_not_touch_users_that_are_not_mentioned,
-                                           create_non_existing_user_groups: create_non_existing_user_groups)
+                      project.import_users(new_users, common_params)
                     end
 
           results.compact!
           counts = results.group_by { |r| r[:type] }.map { |g, r| [g, r.count] }
           counts.each do |category, count|
-            puts "There were #{count} events of type #{category}"
+            GoodData.logger.info("There were #{count} events of type #{category}")
           end
           errors = results.select { |r| r[:type] == :error || r[:type] == :failed }
           return if errors.empty?
 
-          puts 'Printing 10 first errors'
-          puts '========================'
-          pp errors.take(10)
+          GoodData.logger.info('Printing 10 first errors')
+          GoodData.logger.info('========================')
+          GoodData.logger.info(errors.take(10).pretty_inspect)
           fail 'There was an error syncing users'
         end