nobrainer 0.42.0 → 0.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69052877b8fd9f2684f63a0bc7a917812fd771f793d55e7f5182149fc1346643
-  data.tar.gz: 33dbe632e862a31bb4ac95ab8015834947bd1207df3bbdfb921b742274d06517
+  metadata.gz: '035182f731c727beff4562127d0ec36aaa7ad56871f11121940f05b0b72819c2'
+  data.tar.gz: aa14e68a3ff7fded92a16171842dff3a7329cb78c93946af9475255d25bba1ae
 SHA512:
-  metadata.gz: 102682b8e844b1fd574b3d29f386923bb4dfaee33e88e7da6c5615b4901d20023267cbd4e698bec34a94b77718ca04f251f8aebdfd8f74ef5837c637931dd206
-  data.tar.gz: 3cb7abcc47fd15d71abac788e7c5844229d30f532c01000d177d7c5b718848b48d2150cda32a1725ed7d0b68adbb775f4461805d9c2f4768104ba1320eb95d52
+  metadata.gz: b9ab73b56b9df5df5098d7a769581fe367284fa7200b19b7cfd637982f8bf3afd36e071e3f12370504e87e1799bc0d7f1f5ee03ca62617f9f3bfbbb62c6e51df
+  data.tar.gz: 42a7831651d35f55bd39c68c6baaec3b20e845c82e6d5ce562d9e5c2b4184cfcd3daf754ab097bcc3bffe91c05ab873e2d083d37d21c5e44bbfc6afb81197f22

data/CHANGELOG.md

@@ -6,6 +6,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.44.0] - 2023-07-31
+### Added
+- Slow Queries Logger feature logging slow queries in a dedicated log file
+
+### Fixed
+- `first_or_create` with a polymorphic association [#288](https://github.com/NoBrainerORM/nobrainer/issues/288)
+
+## [0.43.0] - 2022-06-16
+### Added
+- Implements polymorphic associations
 
 ## [0.42.0] - 2022-06-15
 ### Added
@@ -124,8 +134,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Locks: bug fix: allow small timeouts in lock()
 - Fix reentrant lock counter on steals
 
-[Unreleased]: https://github.com/nobrainerorm/nobrainer/compare/v0.42.0...HEAD
-[0.41.1]: https://github.com/nobrainerorm/nobrainer/compare/v0.41.1...v0.42.0
+[Unreleased]: https://github.com/nobrainerorm/nobrainer/compare/v0.44.0...HEAD
+[0.44.0]: https://github.com/nobrainerorm/nobrainer/compare/v0.43.0...v0.44.0
+[0.43.0]: https://github.com/nobrainerorm/nobrainer/compare/v0.42.0...v0.43.0
+[0.42.0]: https://github.com/nobrainerorm/nobrainer/compare/v0.41.1...v0.42.0
 [0.41.1]: https://github.com/nobrainerorm/nobrainer/compare/v0.41.0...v0.41.1
 [0.41.0]: https://github.com/nobrainerorm/nobrainer/compare/v0.40.0...v0.41.0
 [0.40.0]: https://github.com/nobrainerorm/nobrainer/compare/v0.36.0...v0.40.0

data/lib/no_brainer/config.rb

@@ -1,29 +1,36 @@
+# frozen_string_literal: true
+
 require 'logger'
 
 module NoBrainer::Config
   SETTINGS = {
-    :app_name               => { :default => ->{ default_app_name } },
-    :environment            => { :default => ->{ default_environment } },
-    :rethinkdb_urls         => { :default => ->{ [default_rethinkdb_url] } },
-    :ssl_options            => { :default => ->{ nil } },
-    :driver                 => { :default => ->{ :regular }, :valid_values => [:regular, :em] },
-    :logger                 => { :default => ->{ default_logger } },
-    :colorize_logger        => { :default => ->{ true }, :valid_values => [true, false] },
-    :warn_on_active_record  => { :default => ->{ true }, :valid_values => [true, false] },
-    :durability             => { :default => ->{ nil } }, # legacy
-    :table_options          => { :default => ->{ {:shards => 1, :replicas => 1, :write_acks => :majority} },
-                                 :valid_keys => [:durability, :shards, :replicas, :primary_replica_tag, :nonvoting_replica_tags, :write_acks] },
-    :run_options            => { :default => ->{ {:durability => default_durability} } },
-    :max_string_length      => { :default => ->{ 255 } },
-    :user_timezone          => { :default => ->{ :local }, :valid_values => [:unchanged, :utc, :local] },
-    :db_timezone            => { :default => ->{ :utc }, :valid_values => [:unchanged, :utc, :local] },
-    :geo_options            => { :default => ->{ {:geo_system => 'WGS84', :unit => 'm'} } },
-    :distributed_lock_class => { :default => ->{ "NoBrainer::Lock" } },
-    :lock_options           => { :default => ->{ { :expire => 60, :timeout => 10 } }, :valid_keys => [:expire, :timeout] },
-    :per_thread_connection  => { :default => ->{ false }, :valid_values => [true, false] },
-    :machine_id             => { :default => ->{ default_machine_id } },
-    :criteria_cache_max_entries => { :default => -> { 10_000 } },
-  }
+    app_name: { default: -> { default_app_name } },
+    colorize_logger: { default: -> { true }, valid_values: [true, false] },
+    criteria_cache_max_entries: { default: -> { 10_000 } },
+    db_timezone: { default: -> { :utc }, valid_values: %i[unchanged utc local] },
+    distributed_lock_class: { default: -> { 'NoBrainer::Lock' } },
+    driver: { default: -> { :regular }, valid_values: %i[regular em] },
+    durability: { default: -> {} }, # legacy
+    environment: { default: -> { default_environment } },
+    geo_options: { default: -> { { geo_system: 'WGS84', unit: 'm' } } },
+    lock_options: { default: -> { { expire: 60, timeout: 10 } }, valid_keys: %i[expire timeout] },
+    log_slow_queries: { default: -> { false } },
+    logger: { default: -> { default_logger } },
+    long_query_time: { default: -> { 10 } },
+    machine_id: { default: -> { default_machine_id } },
+    max_string_length: { default: -> { 255 } },
+    per_thread_connection: { default: -> { false }, valid_values: [true, false] },
+    rethinkdb_urls: { default: -> { [default_rethinkdb_url] } },
+    run_options: { default: -> { { durability: default_durability } } },
+    slow_query_log_file: { default: -> { File.join('/', 'var', 'log', 'rethinkdb', 'slow_queries.log') } },
+    ssl_options: { default: -> {} },
+    table_options: {
+      default: -> { { shards: 1, replicas: 1, write_acks: :majority } },
+      valid_keys: %i[durability shards replicas primary_replica_tag nonvoting_replica_tags write_acks]
+    },
+    user_timezone: { default: -> { :local }, valid_values: %i[unchanged utc local] },
+    warn_on_active_record: { default: -> { true }, valid_values: [true, false] }
+  }.freeze
 
   class << self
     attr_accessor(*SETTINGS.keys)

data/lib/no_brainer/criteria/join.rb

@@ -16,6 +16,7 @@ module NoBrainer::Criteria::Join
         association = model.association_metadata[k.to_sym]
         raise "`#{k}' must be an association on `#{model}'" unless association
         raise "join() does not support through associations" if association.options[:through]
+        raise "join() does not support polymorphic associations" if association.options[:polymorphic]
 
         criteria = association.base_criteria
         criteria = case v

data/lib/no_brainer/criteria/where.rb

@@ -107,7 +107,22 @@ module NoBrainer::Criteria::Where
         when :during then [key_modifier, op, [cast_value(value.first), cast_value(value.last)]]
         else [key_modifier, op, cast_value(value)]
       end
-      BinaryOperator.new(new_key_path, new_key_modifier, new_op, new_value, model, true)
+
+      # When key_path relates to a polymorphic associatoin, the new_key_path is
+      # an Array containing the foreign_type and then the foreign_key.
+      if new_key_path.first.is_a?(Array)
+        foreign_type, foreign_key = new_key_path.first
+
+        MultiOperator.new(
+          :and,
+          [
+            BinaryOperator.new([foreign_type], new_key_modifier, new_op, value.class.to_s, model, true),
+            BinaryOperator.new([foreign_key], new_key_modifier, new_op, value.__send__(value.class.pk_name), model, true)
+          ]
+        )
+      else
+        BinaryOperator.new(new_key_path, new_key_modifier, new_op, new_value, model, true)
+      end
     end
 
     def to_rql(doc)
@@ -185,7 +200,7 @@ module NoBrainer::Criteria::Where
         box_value = key_modifier.in?([:any, :all]) || op == :include
         value = [value] if box_value
         k_v = key_path.reverse.reduce(value) { |v,k| {k => v} }.first
-        k_v = model.association_user_to_model_cast(*k_v)
+        k_v = model.association_user_to_model_cast(*k_v, value.class)
         value = model.cast_user_to_db_for(*k_v)
         value = key_path[1..-1].reduce(value) { |h,k| h[k] }
         value = value.first if box_value
@@ -193,15 +208,43 @@ module NoBrainer::Criteria::Where
       end
     end
 
+    #
+    # This method is used in order to transform association from the passed
+    # `key_path` in to model's field(s).
+    #
+    # When `key_path` contains a field, this method just ensures the given field
+    # is well defined in the owner model.
+    # When `key_path` contains the name of an association, this method updates
+    # the `key_path` in order to replace the association name with the field(s)
+    # behind that association.
+    #
+    # In the case of :
+    # * a polymorphic association name passed as `key_path`, the association
+    #   name will be replaced by the 2 fields representing it (foreign_key and
+    #   foreign_type)
+    # * all other association the association name is replaced by
+    #   the primary_key or the foreign_key depending on the association type
     def cast_key_path(key_path)
       return key_path if casted_values
 
+      # key_path is an Array of symbols representing the path to the key being
+      # queried.
+      #
+      # The Array size can be greater that 1 when quering from a field with,
+      # the type `Hash` and the query is targetting a nested key from the Hash.
+      #
+      # The first Array element is always the field name.
       if key_path.size == 1
-        k, _v = model.association_user_to_model_cast(key_path.first, nil)
-        key_path = [k]
+        # With fields and non-polymorphic associations `keys` will be a symbol
+        # while with a polymorphic association it will be an Array of symbols
+        # being the two fields used by the association.
+        keys, _v = model.association_user_to_model_cast(key_path.first, nil, value.class)
+        key_path = [keys]
       end
 
+      # Ensures fields exist on the model
       model.ensure_valid_key!(key_path.first)
+
       key_path
     end
   end

data/lib/no_brainer/document/association/belongs_to.rb

@@ -2,8 +2,11 @@ class NoBrainer::Document::Association::BelongsTo
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_store_as,
-                     :index, :validates, :required, :uniq, :unique]
+    VALID_OPTIONS = %i[
+      primary_key foreign_key foreign_type class_name foreign_key_store_as
+      index validates required uniq unique polymorphic
+    ]
+
     include NoBrainer::Document::Association::Core::Metadata
     include NoBrainer::Document::Association::EagerLoader::Generic
 
@@ -11,6 +14,12 @@ class NoBrainer::Document::Association::BelongsTo
       options[:foreign_key].try(:to_sym) || :"#{target_name}_#{primary_key}"
     end
 
+    def foreign_type
+      return nil unless options[:polymorphic]
+
+      options[:foreign_type].try(:to_sym) || (:"#{target_name}_type")
+    end
+
     def primary_key
       # We default the primary_key to `:id' and not `target_model.pk_name',
       # because we don't want to require the target_model to be already loaded.
@@ -30,12 +39,22 @@ class NoBrainer::Document::Association::BelongsTo
       end
     end
 
-    def target_model
-      get_model_by_name(options[:class_name] || target_name.to_s.camelize)
+    def target_model(target_class = nil)
+      return if options[:polymorphic] && target_class.nil?
+
+      model_name = if options[:polymorphic]
+                     target_class
+                   else
+                     options[:class_name] || target_name.to_s.camelize
+                   end
+
+      get_model_by_name(model_name)
     end
 
-    def base_criteria
-      target_model.without_ordering
+    def base_criteria(target_class = nil)
+      model = target_model(target_class)
+
+      model ? model.without_ordering : nil
     end
 
     def hook
@@ -47,7 +66,20 @@ class NoBrainer::Document::Association::BelongsTo
         raise "Cannot declare `#{target_name}' in #{owner_model}: the foreign_key `#{foreign_key}' is already used"
       end
 
-      owner_model.field(foreign_key, :store_as => options[:foreign_key_store_as], :index => options[:index])
+      if options[:polymorphic] && options[:class_name]
+        raise 'You cannot set class_name on a polymorphic belongs_to'
+      end
+
+      if options[:polymorphic]
+        if options[:uniq] || options[:unique]
+          owner_model.field(foreign_type, uniq: { scope: foreign_key })
+          owner_model.index([foreign_type, foreign_key])
+        else
+          owner_model.field(foreign_type)
+        end
+      end
+
+      owner_model.field(foreign_key, store_as: options[:foreign_key_store_as], index: options[:index])
 
       unless options[:validates] == false
         owner_model.validates(target_name, options[:validates]) if options[:validates]
@@ -74,17 +106,25 @@ class NoBrainer::Document::Association::BelongsTo
       add_callback_for(:after_validation)
     end
 
-    def cast_attr(k, v)
-      case v
-      when target_model then [foreign_key, v.__send__(primary_key)]
-      when nil          then [foreign_key, nil]
+    def cast_attr(key, value, target_class = nil)
+      case value
+      when target_model(target_class)
+        [foreign_key, value.__send__(primary_key)]
+      when nil
+        if options[:polymorphic]
+          [[foreign_type, foreign_key], nil]
+        else
+          [foreign_key, nil]
+        end
       else
-        opts = { :model => owner_model, :attr_name => k, :type => target_model, :value => v }
-        raise NoBrainer::Error::InvalidType.new(opts)
+        raise NoBrainer::Error::InvalidType.new(
+          model: owner_model, attr_name: key, type: target_model, value: value
+        )
       end
     end
 
     def eager_load_owner_key;  foreign_key; end
+    def eager_load_owner_type; foreign_type; end
     def eager_load_target_key; primary_key; end
   end
 
@@ -97,6 +137,17 @@ class NoBrainer::Document::Association::BelongsTo
     @target_container = nil
   end
 
+  def polymorphic_read
+    return target if loaded?
+
+    target_class = owner.read_attribute(foreign_type)
+    fk = owner.read_attribute(foreign_key)
+
+    if target_class && fk
+      preload(base_criteria(target_class).where(primary_key => fk).first)
+    end
+  end
+
   def read
     return target if loaded?
 
@@ -105,6 +156,12 @@ class NoBrainer::Document::Association::BelongsTo
     end
   end
 
+  def polymorphic_write(target)
+    owner.write_attribute(foreign_key, target.try(primary_key))
+    owner.write_attribute(foreign_type, target.root_class.name)
+    preload(target)
+  end
+
   def write(target)
     assert_target_type(target)
     owner.write_attribute(foreign_key, target.try(primary_key))

data/lib/no_brainer/document/association/core.rb

@@ -33,8 +33,8 @@ module NoBrainer::Document::Association::Core
 
     def hook
       options.assert_valid_keys(*self.class.const_get(:VALID_OPTIONS))
-      delegate("#{target_name}=", :write)
-      delegate("#{target_name}", :read)
+      delegate("#{target_name}=", "#{'polymorphic_' if options[:polymorphic]}write".to_sym)
+      delegate("#{target_name}", "#{'polymorphic_' if options[:polymorphic]}read".to_sym)
     end
 
     def add_callback_for(what)
@@ -62,7 +62,8 @@ module NoBrainer::Document::Association::Core
 
   included { attr_accessor :metadata, :owner }
 
-  delegate :primary_key, :foreign_key, :target_name, :target_model, :base_criteria, :to => :metadata
+  delegate :primary_key, :foreign_key, :foreign_type, :target_name,
+           :target_model, :base_criteria, :to => :metadata
 
   def initialize(metadata, owner)
     @metadata, @owner = metadata, owner

data/lib/no_brainer/document/association/eager_loader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NoBrainer::Document::Association::EagerLoader
   extend self
 
@@ -5,11 +7,22 @@ module NoBrainer::Document::Association::EagerLoader
     # Used in associations to declare generic eager loading capabilities
     # The association should implement loaded?, preload,
     # eager_load_owner_key and eager_load_target_key.
-    def eager_load(docs, additional_criteria=nil)
+    def eager_load(docs, additional_criteria = nil)
       owner_key  = eager_load_owner_key
+      owner_type = eager_load_owner_type
       target_key = eager_load_target_key
 
-      criteria = base_criteria
+      if is_a?(NoBrainer::Document::Association::BelongsTo::Metadata) && owner_type
+        target_class = docs.first.__send__(owner_type)
+
+        if docs.detect { |doc| doc.__send__(owner_type) != target_class }
+          raise NoBrainer::Error::PolymorphicAssociationWithDifferentTypes,
+                "The documents to be eager loaded doesn't have the same " \
+                'type, which is not supported'
+        end
+      end
+
+      criteria = target_class ? base_criteria(target_class) : base_criteria
       criteria = criteria.merge(additional_criteria) if additional_criteria
 
       unloaded_docs = docs.reject { |doc| doc.associations[self].loaded? }

data/lib/no_brainer/document/association/has_many.rb

@@ -2,12 +2,20 @@ class NoBrainer::Document::Association::HasMany
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :dependent, :scope]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :dependent, :scope,
+                     :as]
     include NoBrainer::Document::Association::Core::Metadata
     include NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
-      options[:foreign_key].try(:to_sym) || :"#{owner_model.name.split('::').last.underscore}_#{primary_key}"
+      return options[:foreign_key].try(:to_sym) if options.key?(:foreign_key)
+      return :"#{options[:as]}_#{primary_key}" if options[:as]
+
+      :"#{owner_model.name.split('::').last.underscore}_#{primary_key}"
+    end
+
+    def foreign_type
+      options[:foreign_type].try(:to_sym) || (options[:as] && :"#{options[:as]}_type")
     end
 
     def primary_key
@@ -30,9 +38,9 @@ class NoBrainer::Document::Association::HasMany
       # caching is hard (rails console reload, etc.).
       target_model.association_metadata.values.select do |assoc|
         assoc.is_a?(NoBrainer::Document::Association::BelongsTo::Metadata) and
-        assoc.foreign_key == self.foreign_key                              and
-        assoc.primary_key == self.primary_key                              and
-        assoc.target_model.root_class == owner_model.root_class
+        assoc.foreign_key == foreign_key                                   and
+        assoc.primary_key == primary_key                                   and
+        assoc.target_model(target_model).root_class == owner_model.root_class
       end
     end
 
@@ -46,7 +54,7 @@ class NoBrainer::Document::Association::HasMany
 
       if options[:dependent]
         unless [:destroy, :delete, :nullify, :restrict, nil].include?(options[:dependent])
-          raise "Invalid dependent option: `#{options[:dependent].inspect}'. " +
+          raise "Invalid dependent option: `#{options[:dependent].inspect}'. " \
                 "Valid options are: :destroy, :delete, :nullify, or :restrict"
         end
         add_callback_for(:before_destroy)
@@ -54,12 +62,22 @@ class NoBrainer::Document::Association::HasMany
     end
 
     def eager_load_owner_key;  primary_key; end
+    def eager_load_owner_type; foreign_type; end
     def eager_load_target_key; foreign_key; end
   end
 
   def target_criteria
-    @target_criteria ||= base_criteria.where(foreign_key => owner.__send__(primary_key))
-                                      .after_find(set_inverse_proc)
+    @target_criteria ||= begin
+      query_criteria = { foreign_key => owner.__send__(primary_key) }
+
+      if metadata.options[:as]
+        query_criteria = query_criteria.merge(
+          foreign_type => owner.root_class.name
+        )
+      end
+
+      base_criteria.where(query_criteria).after_find(set_inverse_proc)
+    end
   end
 
   def read

data/lib/no_brainer/document/association.rb

@@ -21,11 +21,12 @@ module NoBrainer::Document::Association
       super
     end
 
-    def association_user_to_model_cast(k,v)
-      association = association_metadata[k]
+    def association_user_to_model_cast(key, value, target_class = nil)
+      association = association_metadata[key]
       case association
-      when NoBrainer::Document::Association::BelongsTo::Metadata then association.cast_attr(k,v)
-      else [k,v]
+      when NoBrainer::Document::Association::BelongsTo::Metadata
+        association.cast_attr(key, value, target_class)
+      else [key, value]
       end
     end
 

data/lib/no_brainer/document/attributes.rb

@@ -154,9 +154,17 @@ module NoBrainer::Document::Attributes
       !!fields[attr.to_sym]
     end
 
-    def ensure_valid_key!(key)
-      return if has_field?(key) || has_index?(key)
-      raise NoBrainer::Error::UnknownAttribute, "`#{key}' is not a valid attribute of #{self}"
+    def ensure_valid_key!(keys)
+      missings = Array(keys).select do |key|
+        has_field?(key) == false && has_index?(key) == false
+      end
+
+      return if missings.empty?
+
+      raise NoBrainer::Error::UnknownAttribute,
+            "`#{missings.join('\', `')}' #{missings.size > 1 ? 'are' : 'is'} " \
+            "not #{'a' if missings.size == 1} valid attribute" \
+            "#{'s' if missings.size > 1} of #{self}"
     end
   end
 end

data/lib/no_brainer/error.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 module NoBrainer::Error
-  class Connection              < RuntimeError; end
-  class DocumentNotFound        < RuntimeError; end
-  class DocumentNotPersisted    < RuntimeError; end
-  class ChildrenExist           < RuntimeError; end
-  class CannotUseIndex          < RuntimeError; end
-  class MissingIndex            < RuntimeError; end
-  class AssociationNotPersisted < RuntimeError; end
-  class ReadonlyField           < RuntimeError; end
-  class MissingAttribute        < RuntimeError; end
-  class UnknownAttribute        < RuntimeError; end
-  class AtomicBlock             < RuntimeError; end
-  class LostLock                < RuntimeError; end
-  class LockInvalidOp           < RuntimeError; end
-  class LockUnavailable         < RuntimeError; end
-  class InvalidPolymorphicType  < RuntimeError; end
+  class AssociationNotPersisted                   < RuntimeError; end
+  class AtomicBlock                               < RuntimeError; end
+  class ChildrenExist                             < RuntimeError; end
+  class Connection                                < RuntimeError; end
+  class DocumentNotFound                          < RuntimeError; end
+  class DocumentNotPersisted                      < RuntimeError; end
+  class InvalidPolymorphicType                    < RuntimeError; end
+  class LockInvalidOp                             < RuntimeError; end
+  class LostLock                                  < RuntimeError; end
+  class LockUnavailable                           < RuntimeError; end
+  class MissingAttribute                          < RuntimeError; end
+  class MissingIndex                              < RuntimeError; end
+  class PolymorphicAssociationWithDifferentTypes  < RuntimeError; end
+  class ReadonlyField                             < RuntimeError; end
+  class UnknownAttribute                          < RuntimeError; end
 
   class DocumentInvalid < RuntimeError
     attr_accessor :instance

data/lib/no_brainer/profiler/logger.rb

@@ -1,45 +1,62 @@
-class NoBrainer::Profiler::Logger
-  def on_query(env)
-    not_indexed = env[:criteria] && env[:criteria].where_present? &&
-                    !env[:criteria].where_indexed? &&
-                    !env[:criteria].model.try(:perf_warnings_disabled)
-
-    level = env[:exception] ? Logger::ERROR :
-             not_indexed ? Logger::INFO : Logger::DEBUG
-    return if NoBrainer.logger.level > level
-
-    msg_duration = (env[:duration] * 1000.0).round(1).to_s
-    msg_duration = " " * [0, 6 - msg_duration.size].max + msg_duration
-    msg_duration = "[#{msg_duration}ms] "
-
-    env[:query_type] = NoBrainer::RQL.type_of(env[:query])
-
-    msg_db = "[#{env[:options][:db]}] " if env[:options][:db]
-    msg_query = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
-
-    msg_exception = "#{env[:exception].class} #{env[:exception].message.split("\n").first}" if env[:exception]
-    msg_exception ||= "perf: filtering without using an index" if not_indexed
-
-    msg_last = nil
-
-    if NoBrainer::Config.colorize_logger
-      query_color = case env[:query_type]
-                    when :write      then "\e[1;31m" # red
-                    when :read       then "\e[1;32m" # green
-                    when :management then "\e[1;33m" # yellow
-                    end
-      msg_duration = [query_color, msg_duration].join
-      msg_db = ["\e[0;34m", msg_db, query_color].join if msg_db
-      if msg_exception
-        exception_color = "\e[0;31m" if level == Logger::ERROR
-        msg_exception = ["\e[0;39m", " -- ", exception_color, msg_exception].compact.join
+# frozen_string_literal: true
+
+module NoBrainer
+  module Profiler
+    class Logger
+      def on_query(env)
+        level = ::Logger::ERROR if env[:exception]
+        level ||= not_indexed(env) ? ::Logger::INFO : ::Logger::DEBUG
+        return if NoBrainer.logger.level > level
+
+        NoBrainer.logger.add(level, build_message(env))
       end
-      msg_last = "\e[0m"
-    end
 
-    msg = [msg_duration, msg_db, msg_query, msg_exception, msg_last].join
-    NoBrainer.logger.add(level, msg)
-  end
+      private
+
+      def build_message(env)
+        msg_duration = (env[:duration] * 1000.0).round(1).to_s
+        msg_duration = (' ' * [0, 6 - msg_duration.size].max) + msg_duration
+        msg_duration = "[#{msg_duration}ms] "
+
+        env[:query_type] = NoBrainer::RQL.type_of(env[:query])
+
+        msg_db = "[#{env[:options][:db]}] " if env[:options][:db]
+        msg_query = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
+
+        msg_exception = "#{env[:exception].class} #{env[:exception].message.split("\n").first}" if env[:exception]
+        msg_exception ||= 'perf: filtering without using an index' if not_indexed(env)
+
+        msg_last = nil
 
-  NoBrainer::Profiler.register(self.new)
+        if NoBrainer::Config.colorize_logger
+          msg_duration = [query_color(env[:query_type]), msg_duration].join
+          msg_db = ["\e[0;34m", msg_db, query_color(env[:query_type])].join if msg_db
+          if msg_exception
+            exception_color = "\e[0;31m" if level == Logger::ERROR
+            msg_exception = ["\e[0;39m", ' -- ', exception_color, msg_exception].compact.join
+          end
+          msg_last = "\e[0m"
+        end
+
+        [msg_duration, msg_db, msg_query, msg_exception, msg_last].join
+      end
+
+      def not_indexed(env)
+        env[:criteria] &&
+          env[:criteria].where_present? &&
+          !env[:criteria].where_indexed? &&
+          !env[:criteria].model.try(:perf_warnings_disabled)
+      end
+
+      def query_color(query_type)
+        {
+          write: "\e[1;31m", # red
+          read: "\e[1;32m", # green
+          management: "\e[1;33m" # yellow
+        }[query_type]
+      end
+
+      NoBrainer::Profiler.register(new)
+    end
+  end
 end

data/lib/no_brainer/profiler/slow_queries.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module NoBrainer
+  module Profiler
+    class SlowQueries < Logger
+      def on_query(env)
+        return unless NoBrainer::Config.log_slow_queries
+
+        query_duration = (env[:duration] * 1000.0).round(1)
+
+        return unless query_duration > NoBrainer::Config.long_query_time
+
+        File.write(
+          NoBrainer::Config.slow_query_log_file,
+          build_message(env),
+          mode: 'a'
+        )
+      end
+
+      NoBrainer::Profiler.register(new)
+    end
+  end
+end

data/lib/no_brainer/query_runner/profiler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class NoBrainer::QueryRunner::Profiler < NoBrainer::QueryRunner::Middleware
   def call(env)
     profiler_start(env)
@@ -10,12 +12,13 @@ class NoBrainer::QueryRunner::Profiler < NoBrainer::QueryRunner::Middleware
   private
 
   require 'no_brainer/profiler/logger'
+  require 'no_brainer/profiler/slow_queries'
 
   def profiler_start(env)
     env[:start_time] = Time.now
   end
 
-  def profiler_end(env, exception=nil)
+  def profiler_end(env, exception = nil)
     return if handle_on_demand_exception?(env, exception)
 
     env[:end_time] = Time.now
@@ -26,10 +29,11 @@ class NoBrainer::QueryRunner::Profiler < NoBrainer::QueryRunner::Middleware
     env[:query_type] = NoBrainer::RQL.type_of(env[:query])
 
     NoBrainer::Profiler.registered_profilers.each do |profiler|
-      begin
+      begin # rubocop:disable Style/RedundantBegin
         profiler.on_query(env)
-      rescue Exception => e
-        STDERR.puts "[NoBrainer] Profiling error: #{e.class} #{e.message}"
+      rescue StandardError => error
+        STDERR.puts "[NoBrainer] #{profiler.class.name} profiler error: " \
+                    "#{error.class} #{error.message}\n#{error.backtrace.join('\n')}"
       end
     end
   end

data/lib/rails/generators/templates/nobrainer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 NoBrainer.configure do |config|
   # app_name is the name of your application in lowercase.
   # When using Rails, the application name is automatically inferred.
@@ -94,4 +96,16 @@ NoBrainer.configure do |config|
   # is cached. The per criteria cache is disabled if it grows too big to avoid
   # out of memory issues.
   # config.criteria_cache_max_entries = 10_000
+
+  # Write queries running longer than config.long_query_time seconds.
+  # The slow query log can be used to find queries that take a long time to
+  # execute and are therefore candidates for optimization.
+  # config.log_slow_queries = true
+
+  # Queries running longer than the bellow value will be logged in a log file if
+  # the above `config.log_slow_queries` is `true`.
+  # config.long_query_time = 10 # seconds
+
+  # Path of the slow queries log file
+  # config.slow_query_log_file = File.join('/', 'var', 'log', 'rethinkdb', 'slow_queries.log')
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.42.0
+  version: 0.44.0
 platform: ruby
 authors:
 - Nicolas Viennot
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-15 00:00:00.000000000 Z
+date: 2023-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -205,6 +205,7 @@ files:
 - lib/no_brainer/profiler.rb
 - lib/no_brainer/profiler/controller_runtime.rb
 - lib/no_brainer/profiler/logger.rb
+- lib/no_brainer/profiler/slow_queries.rb
 - lib/no_brainer/query_runner.rb
 - lib/no_brainer/query_runner/connection_lock.rb
 - lib/no_brainer/query_runner/database_on_demand.rb
@@ -247,7 +248,7 @@ metadata:
   homepage_uri: http://nobrainer.io
   source_code_uri: https://github.com/NoBrainerORM/nobrainer
   changelog_uri: https://github.com/NoBrainerORM/nobrainer/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -263,7 +264,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: A Ruby ORM for RethinkDB
 test_files: []