wcc-contentful 1.2.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f05ea585d54f7ca83c96e018021f88776ebb148cc40b7d719d6199b3a3cd9d0c
-  data.tar.gz: 0da490d12beb9938ec51c0ac40e140420966667b72afebc5c9895cf197308ea8
+  metadata.gz: 58a77a1fbe7e5a7f99d8f13142c29ccac39d7101dfbe2769f542d18e88634a40
+  data.tar.gz: 8a4748e01236daaf0f6bce2c32b2999e02205de77977b6fee01280ea84b83241
 SHA512:
-  metadata.gz: 979360a35356b041dbe0f8bbd4f0e5bfcaf91909ccc567322ceef8493de25300ea09a081e755142fe23bf9cfd5ea86ca7f919d3218d5dec44a98bcab5921af7d
-  data.tar.gz: 9e5f29e70fdcbccffd72aeb8b896e3518d2236cd699704289e8a3fdf1392201dc49671bab0eb83948e79ee079366de90b46add4ce2027e065db2da28b2be4e85
+  metadata.gz: 992a019411bac0fb5c14819db375ed2c8a318c94ccc78b46237598a0ece9aa3646c3b34315738e5c20b7583f43fd0fdec946594cc6e96d92fdaa1b084b425aae
+  data.tar.gz: 4ba8042ea71939b58d51239e4d8b325d6a714f051ff273c2cbcc4116f707eac3b0ca2b695cc73de2904bdcb9cd2f2651927c4987e4967cee514e4d5acd1e9511

data/README.md

@@ -565,7 +565,10 @@ to multiple spaces within the same ruby process!  You just have to create and in
 The {WCC::Contentful::ModelAPI} concern makes this straightforward.  Start by creating your Namespace
 and including the concern:
 ```ruby
-# app/models/my_second_space.rb
+# lib/my_second_space.rb
+
+# Note: This class must be in the "lib" folder in :zeitwerk mode, otherwise Rails 6+ will unload all your constants
+# that were created in the initializer.  Your models which subclass this namespace may reside in the app/models directory.
 class MySecondSpace
   include WCC::Contentful::ModelAPI
 end
@@ -587,6 +590,11 @@ MySecondSpace.configure do |config|
   config.space = ENV['SECOND_CONTENTFUL_SPACE_ID']
   config.environment = ENV['CONTENTFUL_ENVIRONMENT']
 end
+
+# Ensure that models are reloaded in Rails development mode
+Rails.application.config.to_prepare do
+  MySecondSpace.reload!
+end
 ```
 
 Finally, use it:
@@ -614,6 +622,22 @@ sync_engine = MySecondSpace.services.sync_engine
 Note that the above services are not accessible on {WCC::Contentful::Services.instance}
 or via the {WCC::Contentful::ServiceAccessors}.
 
+#### Important Note when using Zeitwerk with Rails 6+
+When using Rails >= 6 with `config.autoloader = :zeitwerk`, Rails will remove any models defined in `app/models` after
+initialization and then load them again when they are referenced.  If you `include WCC::Contentful::ModelAPI` in a class
+defined inside the `app` directory, this will have the effect of deleting all configuration that was set in the initializer
+as well as the constants generated from your schema.
+This will result in one of two errors:
+
+* `NameError (uninitialized constant MySecondSpace::MyContentType)`  
+    if you try to reference a subclass such as `MyContentType < MySecondSpace::MyContentType`
+* `ArgumentError (Not yet configured!)`
+    if you try to `MySecondSpace.find('xxxx')` to load an Entry or Asset
+
+The solution is to have your secondary namespace in a folder which is not in the `autoload_paths`.
+We suggest using `lib`, which will work so long as you have not added the `lib` folder to the `autoload_paths` as some
+uninformed StackOverflow answers suggest you do.
+
 ### Using a sync store with a second space
 
 If you use something other than the CDNAdapter with your second space, you will

data/app/controllers/wcc/contentful/webhook_controller.rb

@@ -36,6 +36,7 @@ module WCC::Contentful
     def authorize_contentful
       config = WCC::Contentful.configuration
 
+      # rubocop:disable Style/SoleNestedConditional
       if config.webhook_username.present? && config.webhook_password.present?
         unless authenticate_with_http_basic do |u, p|
                  u == config.webhook_username &&
@@ -45,6 +46,7 @@ module WCC::Contentful
           return
         end
       end
+      # rubocop:enable Style/SoleNestedConditional
 
       # 'application/vnd.contentful.management.v1+json' is an alias for the 'application/json'
       # content-type, so 'request.content_type' will give 'application/json'

data/lib/tasks/download_schema.rake

@@ -5,7 +5,7 @@ require 'wcc/contentful/downloads_schema'
 
 namespace :wcc_contentful do
   desc 'Downloads the schema from the currently configured space and stores it in ' \
-    'db/contentful-schema.json'
+       'db/contentful-schema.json'
   task download_schema: :environment do
     WCC::Contentful::DownloadsSchema.call
   end

data/lib/wcc/contentful/configuration.rb

@@ -3,22 +3,25 @@
 # This object contains all the configuration options for the `wcc-contentful` gem.
 class WCC::Contentful::Configuration
   ATTRIBUTES = %i[
-    space
     access_token
     app_url
-    management_token
-    environment
-    default_locale
-    preview_token
-    webhook_username
-    webhook_password
-    webhook_jobs
     connection
     connection_options
-    update_schema_file
+    default_locale
+    environment
+    instrumentation_adapter
+    logger
+    management_token
+    preview_token
     schema_file
+    space
     store
-    instrumentation_adapter
+    sync_retry_limit
+    sync_retry_wait
+    update_schema_file
+    webhook_jobs
+    webhook_password
+    webhook_username
   ].freeze
 
   # (required) Sets the Contentful Space ID.
@@ -57,6 +60,17 @@ class WCC::Contentful::Configuration
   # to implement a webhook job.
   attr_accessor :webhook_jobs
 
+  # Sets the maximum number of times that the SyncEngine will retry synchronization
+  # when it detects that the Contentful CDN's cache has not been updated after a webhook.
+  # Default: 2
+  attr_accessor :sync_retry_limit
+
+  # Sets the base ActiveSupport::Duration that the SyncEngine will wait before retrying.
+  # Each subsequent retry uses an exponential backoff, so the second retry will be
+  # after (2 * sync_retry_wait), the third after (4 * sync_retry_wait), etc.
+  # Default: 2.seconds
+  attr_accessor :sync_retry_wait
+
   # Returns true if the currently configured environment is pointing at `master`.
   def master?
     !environment.present?
@@ -145,9 +159,7 @@ class WCC::Contentful::Configuration
   #           WCC::Contentful::InitializationError if the API cannot be reached.
   def update_schema_file=(sym)
     valid_syms = %i[never if_possible if_missing always]
-    unless valid_syms.include?(sym)
-      raise ArgumentError, "update_schema_file must be one of #{valid_syms}"
-    end
+    raise ArgumentError, "update_schema_file must be one of #{valid_syms}" unless valid_syms.include?(sym)
 
     @update_schema_file = sym
   end
@@ -171,23 +183,30 @@ class WCC::Contentful::Configuration
   # to :instrument like ActiveSupport::Notifications.instrument
   attr_accessor :instrumentation_adapter
 
+  # Sets the logger to be used by the wcc-contentful gem, including stores.
+  # Defaults to the rails logger if in a rails context, otherwise creates a new
+  # logger that writes to STDERR.
+  attr_accessor :logger
+
   def initialize
-    @access_token = ENV['CONTENTFUL_ACCESS_TOKEN']
-    @app_url = ENV['APP_URL']
+    @access_token = ENV.fetch('CONTENTFUL_ACCESS_TOKEN', nil)
+    @app_url = ENV.fetch('APP_URL', nil)
     @connection_options = {
       api_url: 'https://cdn.contentful.com/',
       preview_api_url: 'https://preview.contentful.com/',
       management_api_url: 'https://api.contentful.com'
     }
-    @management_token = ENV['CONTENTFUL_MANAGEMENT_TOKEN']
-    @preview_token = ENV['CONTENTFUL_PREVIEW_TOKEN']
-    @space = ENV['CONTENTFUL_SPACE_ID']
+    @management_token = ENV.fetch('CONTENTFUL_MANAGEMENT_TOKEN', nil)
+    @preview_token = ENV.fetch('CONTENTFUL_PREVIEW_TOKEN', nil)
+    @space = ENV.fetch('CONTENTFUL_SPACE_ID', nil)
     @default_locale = nil
     @middleware = []
     @update_schema_file = :if_possible
     @schema_file = 'db/contentful-schema.json'
     @webhook_jobs = []
     @store_factory = WCC::Contentful::Store::Factory.new(self, :direct)
+    @sync_retry_limit = 3
+    @sync_retry_wait = 1.second
   end
 
   # Validates the configuration, raising ArgumentError if anything is wrong.  This

data/lib/wcc/contentful/downloads_schema.rb

@@ -36,7 +36,7 @@ class WCC::Contentful::DownloadsSchema
       begin
         JSON.parse(File.read(@file))
       rescue JSON::ParserError
-        return true
+        return true # rubocop:disable Lint/NoReturnInBeginEndBlocks
       end
 
     existing_cts = contents['contentTypes'].sort_by { |ct| ct.dig('sys', 'id') }
@@ -83,13 +83,14 @@ class WCC::Contentful::DownloadsSchema
   end
 
   def deep_contains_all(expected, actual)
-    if expected.is_a? Array
+    case expected
+    when Array
       expected.each_with_index do |val, i|
         return false unless actual[i]
         return false unless deep_contains_all(val, actual[i])
       end
       true
-    elsif expected.is_a? Hash
+    when Hash
       expected.each do |(key, val)|
         return false unless actual.key?(key)
         return false unless deep_contains_all(val, actual[key])
@@ -107,6 +108,6 @@ class WCC::Contentful::DownloadsSchema
     # only in its treatment of empty arrays in the "validations" field.
     json_string = json_string.gsub(/\[\n\n\s+\]/, '[]')
     # contentful-shell also adds a newline at the end.
-    json_string + "\n"
+    "#{json_string}\n"
   end
 end

data/lib/wcc/contentful/engine.rb

@@ -6,9 +6,7 @@ module WCC::Contentful
       config = WCC::Contentful.configuration
 
       jobs = []
-      if WCC::Contentful::Services.instance.sync_engine&.should_sync?
-        jobs << WCC::Contentful::SyncEngine::Job
-      end
+      jobs << WCC::Contentful::SyncEngine::Job if WCC::Contentful::Services.instance.sync_engine&.should_sync?
       jobs.push(*WCC::Contentful.configuration.webhook_jobs)
 
       jobs.each do |job|
@@ -19,7 +17,7 @@ module WCC::Contentful
                 job.perform_later(event.to_h)
               else
                 Rails.logger.error "Misconfigured webhook job: #{job} does not respond to " \
-                  ':perform_later'
+                                   ':perform_later'
               end
             rescue StandardError => e
               warn "Error in job #{job}: #{e}"

data/lib/wcc/contentful/event.rb

@@ -23,9 +23,7 @@ module WCC::Contentful::Event
 
     def register(constant)
       name = constant.try(:type) || constant.name.demodulize
-      unless constant.respond_to?(:new)
-        raise ArgumentError, "Constant #{constant} does not define 'new'"
-      end
+      raise ArgumentError, "Constant #{constant} does not define 'new'" unless constant.respond_to?(:new)
 
       @event_types ||= {}
       @event_types[name] = constant
@@ -58,6 +56,7 @@ module WCC::Contentful::Event
     attr_reader :sys
     attr_reader :raw
     attr_reader :source
+
     delegate :id, to: :sys
     delegate :type, to: :sys
     delegate :created_at, to: :sys

data/lib/wcc/contentful/exceptions.rb

@@ -12,8 +12,7 @@ module WCC::Contentful
   # Raised when an entry contains a circular reference and cannot be represented
   # as a flat tree.
   class CircularReferenceError < StandardError
-    attr_reader :stack
-    attr_reader :id
+    attr_reader :stack, :id
 
     def initialize(stack, id)
       @id = id
@@ -25,7 +24,7 @@ module WCC::Contentful
       return super unless stack
 
       super + "\n  " \
-        "#{stack.last} points to #{id} which is also it's ancestor\n  " +
+              "#{stack.last} points to #{id} which is also it's ancestor\n  " +
         stack.join('->')
     end
   end

data/lib/wcc/contentful/indexed_representation.rb

@@ -109,9 +109,7 @@ module WCC::Contentful
       ].freeze
 
       def type=(raw_type)
-        unless TYPES.include?(raw_type)
-          raise ArgumentError, "Unknown type #{raw_type}, expected one of: #{TYPES}"
-        end
+        raise ArgumentError, "Unknown type #{raw_type}, expected one of: #{TYPES}" unless TYPES.include?(raw_type)
 
         @type = raw_type
       end
@@ -131,9 +129,7 @@ module WCC::Contentful
 
         if raw_type = hash_or_id.delete('type')
           raw_type = raw_type.to_sym
-          unless TYPES.include?(raw_type)
-            raise ArgumentError, "Unknown type #{raw_type}, expected one of: #{TYPES}"
-          end
+          raise ArgumentError, "Unknown type #{raw_type}, expected one of: #{TYPES}" unless TYPES.include?(raw_type)
 
           @type = raw_type
         end

data/lib/wcc/contentful/instrumentation.rb

@@ -7,11 +7,12 @@ module WCC::Contentful
     def _instrumentation_event_prefix
       @_instrumentation_event_prefix ||=
         # WCC::Contentful => contentful.wcc
-        '.' + (is_a?(Class) || is_a?(Module) ? self : self.class)
+        '.' + (is_a?(Class) || is_a?(Module) ? self : self.class) # rubocop:disable Style/StringConcatenation
           .name.parameterize.split('-').reverse.join('.')
     end
 
     attr_writer :_instrumentation
+
     def _instrumentation
       # look for per-instance instrumentation then try class level
       @_instrumentation || self.class._instrumentation

data/lib/wcc/contentful/link.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 class WCC::Contentful::Link
-  attr_reader :id
-  attr_reader :link_type
-  attr_reader :raw
+  attr_reader :id, :link_type, :raw
 
   LINK_TYPES = {
     Asset: 'Asset',

data/lib/wcc/contentful/link_visitor.rb

@@ -4,9 +4,7 @@
 # It is used internally by the Store layer to compose the resulting resolved hashes.
 # But you can use it too!
 class WCC::Contentful::LinkVisitor
-  attr_reader :entry
-  attr_reader :fields
-  attr_reader :depth
+  attr_reader :entry, :fields, :depth
 
   # @param [Hash] entry The entry hash (resolved or unresolved) to walk
   # @param [Array<Symbol>] The type of fields to select from the entry tree.
@@ -66,7 +64,7 @@ class WCC::Contentful::LinkVisitor
 
   def each_field(field)
     each_locale(field) do |val, locale|
-      if val&.is_a?(Array)
+      if val.is_a?(Array)
         val.each_with_index do |v, index|
           yield(v, field, locale, index) unless v.nil?
         end

data/lib/wcc/contentful/middleware/store/caching_middleware.rb

@@ -36,12 +36,8 @@ module WCC::Contentful::Middleware::Store
     #  figure out how to cache the results of a find_by query, ex:
     #  `find_by('slug' => '/about')`
     def find_by(content_type:, filter: nil, options: nil)
-      if filter&.keys == ['sys.id']
-        # Direct ID lookup, like what we do in `WCC::Contentful::ModelMethods.resolve`
-        # We can return just this item.  Stores are not required to implement :include option.
-        if found = @cache.read(filter['sys.id'])
-          return found
-        end
+      if filter&.keys == ['sys.id'] && found = @cache.read(filter['sys.id'])
+        return found
       end
 
       store.find_by(content_type: content_type, filter: filter, options: options)
@@ -79,8 +75,8 @@ module WCC::Contentful::Middleware::Store
       prev = @cache.read(id)
       return if prev.nil? && LAZILY_CACHEABLE_TYPES.include?(type)
 
-      if (prev_rev = prev&.dig('sys', 'revision')) && (next_rev = json.dig('sys', 'revision'))
-        return prev if next_rev < prev_rev
+      if (prev_rev = prev&.dig('sys', 'revision')) && (next_rev = json.dig('sys', 'revision')) && (next_rev < prev_rev)
+        return prev
       end
 
       # we also set DeletedEntry objects in the cache - no need to go hit the API when we know

data/lib/wcc/contentful/middleware/store.rb

@@ -96,9 +96,9 @@ module WCC::Contentful::Middleware::Store
 
     def count
       if middleware.has_select?
-        raise NameError, "Count cannot be determined because the middleware '#{middleware}'" \
-          " implements the #select? method.  Please use '.to_a.count' to count entries that" \
-          ' pass the #select? method.'
+        raise NameError, "Count cannot be determined because the middleware '#{middleware}' " \
+                         "implements the #select? method.  Please use '.to_a.count' to count entries that " \
+                         'pass the #select? method.'
       end
 
       # The wrapped query may get count from the "Total" field in the response,
@@ -112,9 +112,7 @@ module WCC::Contentful::Middleware::Store
       result = wrapped_query.to_enum
       result = result.select { |x| middleware.select?(x) } if middleware.has_select?
 
-      if options && options[:include]
-        result = result.map { |x| middleware.resolve_includes(x, options[:include]) }
-      end
+      result = result.map { |x| middleware.resolve_includes(x, options[:include]) } if options && options[:include]
 
       result.map { |x| middleware.transform(x) }
     end

data/lib/wcc/contentful/model_api.rb

@@ -51,9 +51,7 @@ module WCC::Contentful::ModelAPI
 
       file = configuration.schema_file
       schema_json = JSON.parse(File.read(file))['contentTypes']
-      unless schema_json
-        raise ArgumentError, 'Please give either a JSON array of content types or file to load from'
-      end
+      raise ArgumentError, 'Please give either a JSON array of content types or file to load from' unless schema_json
 
       @schema = WCC::Contentful::ContentTypeIndexer.from_json_schema(schema_json).types
     end
@@ -98,7 +96,7 @@ module WCC::Contentful::ModelAPI
       loop do
         begin
           # The app may have defined a model and we haven't loaded it yet
-          const = parent.const_missing(const_name)
+          const = parent.const_get(const_name)
           return const if const && const < self
         rescue NameError => e
           raise e unless e.message =~ /uninitialized constant (.+::)*#{const_name}$/
@@ -158,7 +156,7 @@ module WCC::Contentful::ModelAPI
         const_name = klass.name
         begin
           # the const_name is fully qualified so search from root
-          const = Object.const_missing(const_name)
+          const = Object.const_get(const_name)
           register_for_content_type(content_type, klass: const) if const
         rescue NameError => e
           msg = "Error when reloading constant #{const_name} - #{e}"

data/lib/wcc/contentful/model_builder.rb

@@ -61,7 +61,7 @@ module WCC::Contentful
             ct = content_type_from_raw(raw)
             if ct != typedef.content_type
               raise ArgumentError, 'Wrong Content Type - ' \
-                "'#{raw.dig('sys', 'id')}' is a #{ct}, expected #{typedef.content_type}"
+                                   "'#{raw.dig('sys', 'id')}' is a #{ct}, expected #{typedef.content_type}"
             end
             @raw = raw.freeze
 
@@ -107,12 +107,13 @@ module WCC::Contentful
                 # array fields need to resolve to an empty array when nothing is there
                 raw_value = []
               end
-              instance_variable_set('@' + f.name, raw_value)
+              instance_variable_set("@#{f.name}", raw_value)
             end
           end
 
           attr_reader :sys
           attr_reader :raw
+
           delegate :id, to: :sys
           delegate :created_at, to: :sys
           delegate :updated_at, to: :sys
@@ -122,11 +123,11 @@ module WCC::Contentful
           # Make a field for each column:
           typedef.fields.each_value do |f|
             name = f.name
-            var_name = '@' + name
+            var_name = "@#{name}"
             case f.type
             when :Asset, :Link
               define_method(name) do
-                val = instance_variable_get(var_name + '_resolved')
+                val = instance_variable_get("#{var_name}_resolved")
                 return val if val.present?
 
                 _resolve_field(name)

data/lib/wcc/contentful/model_methods.rb

@@ -54,17 +54,15 @@ module WCC::Contentful::ModelMethods
         _instrument 'resolve', id: id, depth: depth, backlinks: backlinked_ids do
           # use include param to do resolution
           store.find_by(content_type: self.class.content_type,
-                        filter: { 'sys.id' => id },
-                        options: context.except(*MODEL_LAYER_CONTEXT_KEYS).merge!({
-                          include: [depth, 10].min
-                        }))
+            filter: { 'sys.id' => id },
+            options: context.except(*MODEL_LAYER_CONTEXT_KEYS).merge!({
+              include: [depth, 10].min
+            }))
         end
-      unless raw
-        raise WCC::Contentful::ResolveError, "Cannot find #{self.class.content_type} with ID #{id}"
-      end
+      raise WCC::Contentful::ResolveError, "Cannot find #{self.class.content_type} with ID #{id}" unless raw
 
       @raw = raw.freeze
-      links.each { |f| instance_variable_set('@' + f, raw.dig('fields', f, sys.locale)) }
+      links.each { |f| instance_variable_set("@#{f}", raw.dig('fields', f, sys.locale)) }
     end
 
     links.each { |f| _resolve_field(f, depth, context, options) }
@@ -142,7 +140,7 @@ module WCC::Contentful::ModelMethods
   def _resolve_field(field_name, depth = 1, context = {}, options = {})
     return if depth <= 0
 
-    var_name = '@' + field_name
+    var_name = "@#{field_name}"
     return unless val = instance_variable_get(var_name)
 
     context = sys.context.to_h.merge(context)
@@ -182,17 +180,17 @@ module WCC::Contentful::ModelMethods
       val = _try_map(val) { |v| load.call(v) }
       val = val.compact if val.is_a? Array
 
-      instance_variable_set(var_name + '_resolved', val)
+      instance_variable_set("#{var_name}_resolved", val)
     rescue WCC::Contentful::CircularReferenceError
       raise unless options[:circular_reference] == :ignore
     end
   end
 
   def _resolved_field?(field_name, depth = 1)
-    var_name = '@' + field_name
+    var_name = "@#{field_name}"
     raw = instance_variable_get(var_name)
     return true if raw.nil? || (raw.is_a?(Array) && raw.all?(&:nil?))
-    return false unless val = instance_variable_get(var_name + '_resolved')
+    return false unless val = instance_variable_get("#{var_name}_resolved")
     return true if depth <= 1
 
     return val.resolved?(depth: depth - 1) unless val.is_a? Array

data/lib/wcc/contentful/model_singleton_methods.rb

@@ -66,7 +66,7 @@ module WCC::Contentful::ModelSingletonMethods
     new(result, options) if result
   end
 
-  def inherited(subclass)
+  def inherited(subclass) # rubocop:disable Lint/MissingSuper
     # If another different class is already registered for this content type,
     # don't auto-register this one.
     return if model_namespace.registered?(content_type)

data/lib/wcc/contentful/rich_text/node.rb

@@ -37,9 +37,7 @@ module WCC::Contentful::RichText
       end
 
       def tokenize(raw, context = nil)
-        unless raw['nodeType'] == node_type
-          raise ArgumentError, "Expected '#{node_type}', got '#{raw['nodeType']}'"
-        end
+        raise ArgumentError, "Expected '#{node_type}', got '#{raw['nodeType']}'" unless raw['nodeType'] == node_type
 
         values =
           members.map do |symbol|

data/lib/wcc/contentful/rich_text.rb

@@ -43,7 +43,7 @@ module WCC::Contentful::RichText
         EmbeddedEntryBlock
       when 'embedded-asset-block'
         EmbeddedAssetBlock
-      when /heading\-(\d+)/
+      when /heading-(\d+)/
         size = Regexp.last_match(1)
         const_get("Heading#{size}")
       else

data/lib/wcc/contentful/rspec.rb

@@ -13,9 +13,7 @@ module WCC::Contentful::RSpec
   # stubs the Model API to return that content type for `.find` and `.find_by`
   # query methods.
   def contentful_stub(const, **attrs)
-    unless const.respond_to?(:content_type_definition)
-      const = WCC::Contentful::Model.resolve_constant(const.to_s)
-    end
+    const = WCC::Contentful::Model.resolve_constant(const.to_s) unless const.respond_to?(:content_type_definition)
     instance = contentful_create(const, **attrs)
 
     # mimic what's going on inside model_singleton_methods.rb

data/lib/wcc/contentful/services.rb

@@ -132,6 +132,15 @@ module WCC::Contentful
     # Allow it to be injected into a store
     alias_method :_instrumentation, :instrumentation
 
+    # Gets the configured logger, defaulting to Rails.logger in a rails context,
+    # or logging to STDERR in a non-rails context.
+    def logger
+      @logger ||=
+        configuration.logger ||
+        (Rails.logger if defined?(Rails)) ||
+        Logger.new($stderr)
+    end
+
     ##
     # This method enables simple dependency injection -
     # If the target has a setter matching the name of one of the services,