deimos-ruby 2.2.0 → 2.2.2

data/lib/deimos/utils/db_poller/base.rb

@@ -11,7 +11,7 @@ module Deimos
       # Base poller class for retrieving and publishing messages.
       class Base
 
-        FATAL_CODES = %i(invalid_msg_size msg_size_too_large)
+        FATAL_CODES = %i(invalid_msg_size msg_size_too_large).freeze
         # @return [Integer]
         BATCH_SIZE = 1000
 
@@ -106,6 +106,7 @@ module Deimos
           raise Deimos::MissingImplementationError
         end
 
+        # rubocop:disable Naming/PredicateMethod
         # @param exception [Exception]
         # @param batch [Array<ActiveRecord::Base>]
         # @param status [PollStatus]
@@ -124,7 +125,6 @@ module Deimos
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
         # @param batch [Array<ActiveRecord::Base>]
         # @param status [PollStatus]
         # @return [Boolean]
@@ -163,7 +163,7 @@ module Deimos
           end
           true
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Naming/PredicateMethod
 
         # Publish batch using the configured producers
         # @param batch [Array<ActiveRecord::Base>]

data/lib/deimos/utils/deadlock_retry.rb

@@ -46,8 +46,8 @@ module Deimos
             raise if count <= 0
 
             Deimos::Logging.log_warn(
-              message: 'Deadlock encountered when trying to execute query. '\
-                "Retrying. #{count} attempt(s) remaining",
+              message: 'Deadlock encountered when trying to execute query. ' \
+                       "Retrying. #{count} attempt(s) remaining",
               tags: tags
             )
 

data/lib/deimos/utils/outbox_producer.rb

@@ -14,10 +14,10 @@ module Deimos
       # @return [Integer]
       MAX_DELETE_ATTEMPTS = 3
       # @return [Array<Symbol>]
-      FATAL_CODES = %i(invalid_msg_size msg_size_too_large)
+      FATAL_CODES = %i(invalid_msg_size msg_size_too_large).freeze
 
       # @param logger [Logger]
-      def initialize(logger=Logger.new(STDOUT))
+      def initialize(logger=Logger.new($stdout))
         @id = SecureRandom.uuid
         @logger = logger
         @logger.push_tags("OutboxProducer #{@id}") if @logger.respond_to?(:push_tags)
@@ -81,13 +81,14 @@ module Deimos
 
         KafkaTopicInfo.clear_lock(@current_topic, @id)
       rescue StandardError => e
-        @logger.error("Error processing messages for topic #{@current_topic}: #{e.class.name}: #{e.message} #{e.backtrace.join("\n")}")
+        @logger.error('Error processing messages for topic ' \
+                      "#{@current_topic}: #{e.class.name}: #{e.message} #{e.backtrace.join("\n")}")
         KafkaTopicInfo.register_error(@current_topic, @id)
       end
 
       # Process a single batch in a topic.
       # @return [void]
-      def process_topic_batch
+      def process_topic_batch # rubocop:disable Naming/PredicateMethod
         messages = retrieve_messages
         return false if messages.empty?
 
@@ -95,9 +96,9 @@ module Deimos
         compacted_messages = compact_messages(messages)
         log_messages(compacted_messages)
         Karafka.monitor.instrument('deimos.outbox.produce', topic: @current_topic, messages: compacted_messages) do
-          begin
+
             produce_messages(compacted_messages.map(&:karafka_message))
-          rescue WaterDrop::Errors::ProduceManyError => e
+        rescue WaterDrop::Errors::ProduceManyError => e
             if FATAL_CODES.include?(e.cause.try(:code))
               @logger.error('Message batch too large, deleting...')
               delete_messages(messages)
@@ -106,7 +107,7 @@ module Deimos
               Deimos.log_error("Got error #{e.cause.class.name} when publishing #{batch_size} messages, retrying...")
               retry
             end
-          end
+
         end
         delete_messages(messages)
         Deimos.config.metrics&.increment(
@@ -203,13 +204,12 @@ module Deimos
       def produce_messages(batch)
         batch_size = batch.size
         current_index = 0
-        begin
-          batch[current_index..-1].in_groups_of(batch_size, false).each do |group|
-            @logger.debug("Publishing #{group.size} messages to #{@current_topic}")
-            Karafka.producer.produce_many_sync(group)
-            current_index += group.size
-            @logger.info("Sent #{group.size} messages to #{@current_topic}")
-          end
+
+        batch[current_index..-1].in_groups_of(batch_size, false).each do |group|
+          @logger.debug("Publishing #{group.size} messages to #{@current_topic}")
+          Karafka.producer.produce_many_sync(group)
+          current_index += group.size
+          @logger.info("Sent #{group.size} messages to #{@current_topic}")
         end
       end
 

data/lib/deimos/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deimos
-  VERSION = '2.2.0'
+  VERSION = '2.2.2'
 end

data/lib/deimos.rb

@@ -50,7 +50,7 @@ module Deimos
     deimos.batch_consumption.invalid_records
     deimos.batch_consumption.valid_records
     deimos.outbox.produce
-  )
+  ).freeze
 
   class << self
 
@@ -66,7 +66,7 @@ module Deimos
 
     # @param schema [String, Symbol]
     # @param namespace [String]
-    # @return [Deimos::SchemaBackends::Base]
+    # @return [Class<Deimos::SchemaBackends::Base>]
     def schema_backend(schema:, namespace:, backend: Deimos.config.schema.backend)
       if config.schema.use_schema_classes
         # Initialize an instance of the provided schema
@@ -170,9 +170,9 @@ module Deimos
     # @return [Karafka::Routing::Topic,nil]
     def karafka_config_for(topic: nil, producer: nil)
       if topic
-        karafka_configs.find { |t| t.name == topic}
+        karafka_configs.find { |t| t.name == topic }
       elsif producer
-        karafka_configs.find { |t| t.producer_classes&.include?(producer)}
+        karafka_configs.find { |t| t.producer_classes&.include?(producer) }
       end
     end
 

data/lib/generators/deimos/active_record_generator.rb

@@ -10,6 +10,7 @@ module Deimos
     # Generator for ActiveRecord model and migration.
     class ActiveRecordGenerator < Rails::Generators::Base
       include Rails::Generators::Migration
+
       if Rails.version < '4'
         extend(ActiveRecord::Generators::Migration)
       else
@@ -47,7 +48,7 @@ module Deimos
         # @return [String]
         def schema
           last_dot = self.full_schema.rindex('.')
-          self.full_schema[last_dot + 1..-1]
+          self.full_schema[(last_dot + 1)..-1]
         end
 
         # @return [String]

data/lib/generators/deimos/db_poller_generator.rb

@@ -8,6 +8,7 @@ module Deimos
     # Generate the database backend migration.
     class DbPollerGenerator < Rails::Generators::Base
       include Rails::Generators::Migration
+
       if Rails.version < '4'
         extend(ActiveRecord::Generators::Migration)
       else

data/lib/generators/deimos/outbox_backend_generator.rb

@@ -8,6 +8,7 @@ module Deimos
     # Generate the database backend migration.
     class OutboxBackendGenerator < Rails::Generators::Base
       include Rails::Generators::Migration
+
       if Rails.version < '4'
         extend(ActiveRecord::Generators::Migration)
       else

data/lib/generators/deimos/schema_class_generator.rb

@@ -75,7 +75,7 @@ module Deimos
           elsif schema.respond_to?(:items)
             [schema.items]
           elsif schema.respond_to?(:schemas)
-            schema.schemas.reject { |s| s.class == Avro::Schema::PrimitiveSchema }
+            schema.schemas.reject { |s| s.instance_of?(Avro::Schema::PrimitiveSchema) }
           else
             []
           end
@@ -172,6 +172,7 @@ module Deimos
         Deimos.karafka_configs.each do |config|
           schema_name = config.schema
           next if schema_name.nil?
+
           namespace = config.namespace || Deimos.config.producers.schema_namespace
           key_schema_name = config.key_config[:schema]
 
@@ -215,7 +216,7 @@ module Deimos
         _set_instance_variables(schema, key_config)
 
         temp = schema.is_a?(Avro::Schema::RecordSchema) ? _record_class_template : _enum_class_template
-        res = ERB.new(temp, nil, '-')
+        res = ERB.new(temp, trim_mode: '-')
         res.result(binding)
       end
 

data/lib/generators/deimos/v2_generator.rb

@@ -20,186 +20,215 @@ module Deimos
       end
     end
 
-      source_root File.expand_path('v2/templates', __dir__)
+    source_root File.expand_path('v2/templates', __dir__)
 
-      no_commands do
-        def deimos_config
-          Deimos.config
-        end
+    no_commands do
+      def deimos_config
+        Deimos.config
+      end
 
-        def deimos_configs
-          configs = {
-            producers: %i(topic_prefix disabled backend),
-            schema: %i(backend registry_url user password path generated_class_path use_schema_classes
-                       nest_child_schemas use_full_namespace schema_namespace_map),
-            db_producer: %i(log_topics compact_topics),
-          }
-
-          response = {}
-          configs.each do |group, settings|
-            group_setting = deimos_config.send(group)
-            next if settings.all? { |s| group_setting.default_value?(s)}
-
-            response[group] = {}
-            settings.each do |field|
-              unless group_setting.default_value?(field.to_sym)
-                response[group][field.to_s] = group_setting.send(field.to_sym)
-              end
+      def deimos_configs
+        configs = {
+          producers: %i(topic_prefix disabled backend),
+          schema: %i(backend registry_url user password path generated_class_path use_schema_classes
+                     nest_child_schemas use_full_namespace schema_namespace_map),
+          db_producer: %i(log_topics compact_topics)
+        }
+
+        response = {}
+        configs.each do |group, settings|
+          group_setting = deimos_config.send(group)
+          next if settings.all? { |s| group_setting.default_value?(s) }
+
+          response[group] = {}
+          settings.each do |field|
+            unless group_setting.default_value?(field.to_sym)
+              response[group][field.to_s] = group_setting.send(field.to_sym)
             end
           end
-          response
         end
+        response
+      end
 
-        def setup_configs
-          configs = {}
-          configs[:client_id] = if deimos_config.kafka.client_id && deimos_config.kafka.client_id != 'phobos'
-                                  deimos_config.kafka.client_id
+      def setup_configs
+        configs = {}
+        configs[:client_id] = if deimos_config.kafka.client_id &&
+                                 deimos_config.kafka.client_id != 'phobos'
+                                deimos_config.kafka.client_id
+                              else
+                                subclass = Rails::Application.subclasses.first
+                                if subclass
+                                  subclass.name.gsub('::Application', '').underscore
                                 else
-                                  Rails::Application.subclasses.first&.name&.gsub('::Application', '')&.underscore
+                                  nil
                                 end
-          if deimos_config.consumer_objects.any? { |c| c.max_concurrency.present? }
-            configs[:concurrency] = deimos_config.consumer_objects.map(&:max_concurrency).compact.max
-          end
-          if deimos_config.consumer_objects.any? { |c| c.max_wait_time.present? }
-            configs[:max_wait_time] = deimos_config.consumer_objects.map(&:max_wait_time).compact.max
-          end
-          configs.compact
+                              end
+        if deimos_config.consumer_objects.any? { |c| c.max_concurrency.present? }
+          configs[:concurrency] = deimos_config.consumer_objects.map(&:max_concurrency).compact.max
         end
-
-        def default_kafka_configs
-          configs = {}
-          configs["bootstrap.servers"] = deimos_config.kafka.seed_brokers.join(',')
-          configs["socket.connection.setup.timeout.ms"] = deimos_config.kafka.connect_timeout * 1000
-          configs["socket.timeout.ms"] = deimos_config.kafka.socket_timeout * 1000
-          configs["security.protocol"] = if deimos_config.kafka.ssl.enabled
-                                           "ssl"
-                                         elsif deimos_config.kafka.sasl.enabled
-                                           if deimos_config.kafka.sasl.enforce_ssl
-                                             "sasl_ssl"
-                                           else
-                                             "sasl_plain"
-                                           end
-                                         end
-          configs["ssl.ca.location"] = deimos_config.kafka.ssl.ca_cert
-          configs["ssl.certificate.location"] = deimos_config.kafka.ssl.client_cert
-          configs["ssl.key.location"] = deimos_config.kafka.ssl.client_cert_key
-          configs["ssl.endpoint.identification.algorithm"] = "https" if deimos_config.kafka.ssl.verify_hostname
-          configs["sasl.kerberos.principal"] = deimos_config.kafka.sasl.gssapi_principal
-          configs["sasl.kerberos.keytab"] = deimos_config.kafka.sasl.gssapi_keytab
-          configs["sasl.username"] = deimos_config.kafka.sasl.plain_username || deimos_config.kafka.sasl.scram_username
-          configs["sasl.password"] = deimos_config.kafka.sasl.plain_password || deimos_config.kafka.sasl.scram_password
-          configs["sasl.mechanisms"] = deimos_config.kafka.sasl.scram_mechanism
-          configs["request.required.acks"] = deimos_config.producers.required_acks
-          configs["message.send.max.retries"] = deimos_config.producers.max_retries
-          configs["retry.backoff.ms"] = deimos_config.producers.retry_backoff * 1000 if deimos_config.producers.retry_backoff
-          configs["compression.codec"] = deimos_config.producers.compression_codec
-          configs.compact
+        if deimos_config.consumer_objects.any? { |c| c.max_wait_time.present? }
+          configs[:max_wait_time] = deimos_config.consumer_objects.map(&:max_wait_time).compact.max
         end
+        configs.compact
+      end
 
-        def default_configs
-          {
-            payload_log: deimos_config.payload_log,
-            reraise_errors: deimos_config.consumers.reraise_errors,
-            replace_associations: deimos_config.consumers.replace_associations,
-            namespace: deimos_config.producers.schema_namespace,
-            use_schema_classes: deimos_config.schema.use_schema_classes
-          }.compact
+      def default_kafka_configs
+        configs = {}
+        configs['bootstrap.servers'] = deimos_config.kafka.seed_brokers.join(',')
+        configs['socket.connection.setup.timeout.ms'] = deimos_config.kafka.connect_timeout * 1000
+        configs['socket.timeout.ms'] = deimos_config.kafka.socket_timeout * 1000
+        configs['security.protocol'] = if deimos_config.kafka.ssl.enabled
+                                         'ssl'
+                                       elsif deimos_config.kafka.sasl.enabled
+                                         if deimos_config.kafka.sasl.enforce_ssl
+                                           'sasl_ssl'
+                                         else
+                                           'sasl_plain'
+                                         end
+                                       end
+        configs['ssl.ca.location'] = deimos_config.kafka.ssl.ca_cert
+        configs['ssl.certificate.location'] = deimos_config.kafka.ssl.client_cert
+        configs['ssl.key.location'] = deimos_config.kafka.ssl.client_cert_key
+        if deimos_config.kafka.ssl.verify_hostname
+          configs['ssl.endpoint.identification.algorithm'] = 'https'
         end
-
-        def consumer_configs
-          deimos_config.consumer_objects.group_by(&:group_id).map do |group_id, consumers|
-            [group_id, consumers.map do |consumer|
-              kafka_configs = {}
-              kafka_configs["auto.offset.reset"] = consumer.start_from_beginning ? 'earliest' : 'latest'
-              kafka_configs["session.timeout.ms"] = consumer.session_timeout * 1000 unless consumer.default_value?(:session_timeout)
-              kafka_configs["auto.commit.interval.ms"] = consumer.offset_commit_interval * 1000 unless consumer.default_value?(:offset_commit_interval)
-              kafka_configs["heartbeat.interval.ms"] = consumer.heartbeat_interval * 1000 unless consumer.default_value?(:heartbeat_interval)
-              configs = {
-                kafka: kafka_configs.compact,
-                topic: consumer.topic,
-                consumer: ProcString.new(consumer.class_name),
-                schema: consumer.schema,
-                namespace: consumer.namespace,
-                key_config: consumer.key_config,
-              }
-              configs[:use_schema_classes] = consumer.use_schema_classes unless consumer.default_value?(:use_schema_classes)
-              configs[:max_db_batch_size] = consumer.max_db_batch_size unless consumer.default_value?(:max_db_batch_size)
-              configs[:bulk_import_id_column] = consumer.bulk_import_id_column unless consumer.default_value?(:bulk_import_id_column)
-              configs[:replace_associations] = consumer.replace_associations unless consumer.default_value?(:replace_associations)
-              configs[:save_associations_first] = consumer.save_associations_first unless consumer.default_value?(:save_associations_first)
-              configs[:active] = false if consumer.disabled
-              configs[:each_message] = true unless consumer.delivery.to_s == 'inline_batch'
-              configs
-            end]
-          end.to_h
+        configs['sasl.kerberos.principal'] = deimos_config.kafka.sasl.gssapi_principal
+        configs['sasl.kerberos.keytab'] = deimos_config.kafka.sasl.gssapi_keytab
+        configs['sasl.username'] = deimos_config.kafka.sasl.plain_username ||
+                                   deimos_config.kafka.sasl.scram_username
+        configs['sasl.password'] = deimos_config.kafka.sasl.plain_password ||
+                                   deimos_config.kafka.sasl.scram_password
+        configs['sasl.mechanisms'] = deimos_config.kafka.sasl.scram_mechanism
+        configs['request.required.acks'] = deimos_config.producers.required_acks
+        configs['message.send.max.retries'] = deimos_config.producers.max_retries
+        if deimos_config.producers.retry_backoff
+          configs['retry.backoff.ms'] = deimos_config.producers.retry_backoff * 1000
         end
+        configs['compression.codec'] = deimos_config.producers.compression_codec
+        configs.compact
+      end
 
-        def producer_configs
-          deimos_config.producer_objects.map do |producer|
-            {
-              topic: producer.topic,
-              producer_class: ProcString.new(producer.class_name),
-              schema: producer.schema,
-              namespace: producer.namespace || deimos_config.producers.schema_namespace,
-              key_config: producer.key_config,
-              use_schema_classes: producer.use_schema_classes
-            }.compact
-          end
-        end
+      def default_configs
+        {
+          payload_log: deimos_config.payload_log,
+          reraise_errors: deimos_config.consumers.reraise_errors,
+          replace_associations: deimos_config.consumers.replace_associations,
+          namespace: deimos_config.producers.schema_namespace,
+          use_schema_classes: deimos_config.schema.use_schema_classes
+        }.compact
+      end
 
-        def rename_consumer_methods
-          deimos_config.consumer_objects.each do |consumer|
-            consumer.class_name.constantize
-            file = Object.const_source_location(consumer.class_name)[0]
-            if file.to_s.include?(Rails.root.to_s)
-              gsub_file(file, /([\t ]+)def consume\((\w+)(, *(\w+)?)\)/,
-                        "\\1def consume_message(message)\n\\1  \\2 = message.payload\n\\1  \\4 = message.metadata")
-              gsub_file(file, /([\t ]+)def consume_batch\((\w+)(, *(\w+)?)\)/,
-                        "\\1def consume_batch\n\\1  \\2 = messages.payloads\n\\1  \\4 = messages.metadata")
-              gsub_file(file, /def record_attributes\((\w+)\)/,
-                        "def record_attributes(\\1, key)")
+      def consumer_configs
+        deimos_config.consumer_objects.group_by(&:group_id).map { |group_id, consumers|
+          [group_id, consumers.map do |consumer|
+            kafka_configs = {}
+            kafka_configs['auto.offset.reset'] = consumer.start_from_beginning ? 'earliest' : 'latest'
+            unless consumer.default_value?(:session_timeout)
+              kafka_configs['session.timeout.ms'] = consumer.session_timeout * 1000
             end
-          end
-        end
+            unless consumer.default_value?(:offset_commit_interval)
+              kafka_configs['auto.commit.interval.ms'] = consumer.offset_commit_interval * 1000
+            end
+            unless consumer.default_value?(:heartbeat_interval)
+              kafka_configs['heartbeat.interval.ms'] = consumer.heartbeat_interval * 1000
+            end
+            configs = {
+              kafka: kafka_configs.compact,
+              topic: consumer.topic,
+              consumer: ProcString.new(consumer.class_name),
+              schema: consumer.schema,
+              namespace: consumer.namespace,
+              key_config: consumer.key_config
+            }
+            unless consumer.default_value?(:use_schema_classes)
+              configs[:use_schema_classes] = consumer.use_schema_classes
+            end
+            unless consumer.default_value?(:max_db_batch_size)
+              configs[:max_db_batch_size] = consumer.max_db_batch_size
+            end
+            unless consumer.default_value?(:bulk_import_id_column)
+              configs[:bulk_import_id_column] = consumer.bulk_import_id_column
+            end
+            unless consumer.default_value?(:replace_associations)
+              configs[:replace_associations] = consumer.replace_associations
+            end
+            unless consumer.default_value?(:save_associations_first)
+              configs[:save_associations_first] = consumer.save_associations_first
+            end
+            configs[:active] = false if consumer.disabled
+            configs[:each_message] = true unless consumer.delivery.to_s == 'inline_batch'
+            configs
+          end]
+        }.to_h
+      end
 
-        def fix_specs
-          Dir["*/**/*_spec.rb"].each do |file|
-            gsub_file(file, /,\s*call_original: true/, "")
-            gsub_file(file, 'Deimos::Backends::Test.sent_messages', "Deimos::TestHelpers.sent_messages")
-          end
+      def producer_configs
+        deimos_config.producer_objects.map do |producer|
+          {
+            topic: producer.topic,
+            producer_class: ProcString.new(producer.class_name),
+            schema: producer.schema,
+            namespace: producer.namespace || deimos_config.producers.schema_namespace,
+            key_config: producer.key_config,
+            use_schema_classes: producer.use_schema_classes
+          }.compact
         end
+      end
 
-        def process_all_files
-          template('karafka.rb.tt', "karafka.rb", force: true)
-          rename_consumer_methods
-          fix_specs
-          insert_into_file("Gemfile", "  gem 'karafka-testing'\n", after: "group :test do\n")
-          # to avoid inserting multiple times, just in case there isn't a single group :test
-          insert_into_file("Gemfile", "  gem 'karafka-testing'\n", after: /group .*test.* do\n/)
+      def rename_consumer_methods
+        deimos_config.consumer_objects.each do |consumer|
+          consumer.class_name.constantize
+          file = Object.const_source_location(consumer.class_name)[0]
+          next unless file.to_s.include?(Rails.root.to_s)
+
+          gsub_file(file, /([\t ]+)def consume\((\w+)(, *(\w+)?)\)/,
+                    "\\1def consume_message(message)\n\\1  \\2 = message.payload\n\\1  \\4 = message.metadata")
+          gsub_file(file, /([\t ]+)def consume_batch\((\w+)(, *(\w+)?)\)/,
+                    "\\1def consume_batch\n\\1  \\2 = messages.payloads\n\\1  \\4 = messages.metadata")
+          gsub_file(file, /def record_attributes\((\w+)\)/,
+                    'def record_attributes(\\1, key)')
         end
-
       end
 
-      desc 'Generate and update app files for version 2.0'
-      # @return [void]
-      def generate
-        process_all_files
-        say "Generation complete! You are safe to remove the existing initializer that configures Deimos.", :green
-        print_warnings
+      def fix_specs
+        Dir['*/**/*_spec.rb'].each do |file|
+          gsub_file(file, /,\s*call_original: true/, '')
+          gsub_file(file, 'Deimos::Backends::Test.sent_messages',
+                    'Deimos::TestHelpers.sent_messages')
+        end
       end
 
-      def print_warnings
-        say "Note: The following settings cannot be determined by the generator:", :yellow
-        say "*  logger / phobos_logger (dynamic object, cannot be printed out)", :yellow
-        say "*  kafka.sasl.oauth_token_provider", :yellow
-        say "*  producers.max_buffer_size", :yellow
-        say "*  metrics", :yellow
-        say "*  tracer", :yellow
-        say "*  consumers.bulk_import_id_generator", :yellow
-        say "*  consumer.fatal_error", :yellow
-        say "*  consumer.backoff (only handles minimum, not maximum)", :yellow
-        say "For more information, see https://github.com/flipp-oss/deimos/blob/master/docs/UPGRADING.md", :yellow
+      def process_all_files
+        template('karafka.rb.tt', 'karafka.rb', force: true)
+        rename_consumer_methods
+        fix_specs
+        insert_into_file('Gemfile', "  gem 'karafka-testing'\n", after: "group :test do\n")
+        # to avoid inserting multiple times, just in case there isn't a single group :test
+        insert_into_file('Gemfile', "  gem 'karafka-testing'\n", after: /group .*test.* do\n/)
       end
+
+    end
+
+    desc 'Generate and update app files for version 2.0'
+    # @return [void]
+    def generate
+      process_all_files
+      say('Generation complete! You are safe to remove the existing initializer that configures Deimos.', :green)
+      print_warnings
+    end
+
+    def print_warnings
+      say('Note: The following settings cannot be determined by the generator:', :yellow)
+      say('*  logger / phobos_logger (dynamic object, cannot be printed out)', :yellow)
+      say('*  kafka.sasl.oauth_token_provider', :yellow)
+      say('*  producers.max_buffer_size', :yellow)
+      say('*  metrics', :yellow)
+      say('*  tracer', :yellow)
+      say('*  consumers.bulk_import_id_generator', :yellow)
+      say('*  consumer.fatal_error', :yellow)
+      say('*  consumer.backoff (only handles minimum, not maximum)', :yellow)
+      say('For more information, see https://github.com/flipp-oss/deimos/blob/master/docs/UPGRADING.md', :yellow)
+    end
     end
   end
 end

data/spec/active_record_batch_consumer_association_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Lint/ConstantDefinitionInBlock
 module ActiveRecordBatchConsumerTest # rubocop:disable Metrics/ModuleLength
   describe Deimos::ActiveRecordConsumer,
            'Batch Consumer with MySQL handling associations',
@@ -179,8 +180,8 @@ module ActiveRecordBatchConsumerTest # rubocop:disable Metrics/ModuleLength
         expect {
           publish_batch([{ key: 2,
                            payload: { test_id: 'xyz', some_int: 5, title: 'Widget Title' } }])
-        }.to raise_error('Create bulk_import_id on the widgets table. Run rails g deimos:bulk_import_id {table}'\
-        ' to create the migration.')
+        }.to raise_error('Create bulk_import_id on the widgets table. Run rails g deimos:bulk_import_id {table} ' \
+                         'to create the migration.')
       end
     end
 
@@ -204,6 +205,7 @@ module ActiveRecordBatchConsumerTest # rubocop:disable Metrics/ModuleLength
 
     context 'with one-to-many relationship in association and default bulk_import_id' do
       let(:replace_associations) { false }
+
       before(:each) do
         consumer_class.record_attributes_proc = proc do |payload|
           {
@@ -243,6 +245,7 @@ module ActiveRecordBatchConsumerTest # rubocop:disable Metrics/ModuleLength
 
     context 'with replace_associations on' do
       let(:replace_associations) { true }
+
       before(:each) do
         consumer_class.record_attributes_proc = proc do |payload|
           {
@@ -318,3 +321,4 @@ module ActiveRecordBatchConsumerTest # rubocop:disable Metrics/ModuleLength
     end
            end
 end
+# rubocop:enable Lint/ConstantDefinitionInBlock