nobrainer 0.22.0 → 0.28.0

data/lib/no_brainer/query_runner/run_options.rb

@@ -1,35 +1,55 @@
 class NoBrainer::QueryRunner::RunOptions < NoBrainer::QueryRunner::Middleware
-  # XXX NoBrainer::Database#drop() uses Thread.current[:nobrainer_options]
-
   def self.with_database(db_name, &block)
+    STDERR.puts "[NoBrainer] `with_database()' is deprecated, please use `with(db: ...)' instead"
     with(:db => db_name, &block)
   end
 
   def self.with(options={}, &block)
-    old_options = Thread.current[:nobrainer_options]
-    Thread.current[:nobrainer_options] = (old_options || {}).merge(options.symbolize_keys)
-    block.call if block
+    STDERR.puts "[NoBrainer] `with(...)' is deprecated, please use `run_with(...)' instead"
+    run_with(options, &block)
+  end
+
+  def self.current_run_options
+    Thread.current[:nobrainer_run_with] || {}
+  end
+
+  def self.run_with(options={}, &block)
+    options = options.symbolize_keys
+
+    if options[:database]
+      STDERR.puts "[NoBrainer] `run_with(database: ...)' is deprecated, please use `run_with(db: ...)' instead"
+      options[:db] = options.delete(:database)
+    end
+
+    old_options = Thread.current[:nobrainer_run_with]
+    Thread.current[:nobrainer_run_with] = (old_options || {}).merge(options)
+    block.call
   ensure
-    Thread.current[:nobrainer_options] = old_options
+    Thread.current[:nobrainer_run_with] = old_options
   end
 
   def call(env)
-    env[:options].symbolize_keys!
-    if Thread.current[:nobrainer_options]
-      env[:options].reverse_merge!(Thread.current[:nobrainer_options])
-    end
+    options = env[:options].symbolize_keys
+    options = self.class.current_run_options.merge(options)
 
     if NoBrainer::Config.durability.to_s != 'hard'
-      env[:options].reverse_merge!(:durability => NoBrainer::Config.durability)
+      options[:durability] ||= NoBrainer::Config.durability
     end
 
-    if env[:options][:db] && !env[:options][:db].is_a?(RethinkDB::RQL)
-      env[:db_name] = env[:options][:db].to_s
-      env[:options][:db] = RethinkDB::RQL.new.db(env[:db_name])
+    options[:db] = options[:db].to_s if options[:db]
+    if options[:db].blank? || options[:db] == NoBrainer.default_db
+      options.delete(:db)
     end
 
-    env[:criteria] = env[:options].delete(:criteria)
+    env[:criteria] = options.delete(:criteria)
+
+    if options[:profile] && env[:criteria].try(:raw?) == false
+      STDERR.puts "[NoBrainer]"
+      STDERR.puts "[NoBrainer]\e[1;31m Please use `.raw' in your criteria when profiling\e[0m"
+      STDERR.puts "[NoBrainer]"
+    end
 
+    env[:options] = options
     @runner.call(env)
   end
 end

data/lib/no_brainer/query_runner/table_on_demand.rb

@@ -15,24 +15,31 @@ class NoBrainer::QueryRunner::TableOnDemand < NoBrainer::QueryRunner::Middleware
 
   private
 
-  def auto_create_table(env, database_name, table_name)
-    model ||= NoBrainer::Document::Core._all.select { |m| m.table_name == table_name }.first
-    model ||= NoBrainer::Document::Core._all_nobrainer.select { |m| m.table_name == table_name }.first
-
+  def auto_create_table(env, db_name, table_name)
+    model = NoBrainer::Document.all(:types => [:user, :nobrainer])
+                               .detect { |m| m.table_name == table_name }
     if model.nil?
-      raise "Auto table creation is not working for `#{database_name}.#{table_name}` -- Can't find the corresponding model."
+      raise "Auto table creation is not working for `#{db_name}.#{table_name}` -- Can't find the corresponding model."
+    end
+
+    if env[:last_auto_create_table] == [db_name, table_name]
+      raise "Auto table creation is not working for `#{db_name}.#{table_name}`"
     end
+    env[:last_auto_create_table] = [db_name, table_name]
+
+    create_options = model.table_create_options
 
-    if env[:last_auto_create_table] == [database_name, table_name]
-      raise "Auto table creation is not working for `#{database_name}.#{table_name}`"
+    NoBrainer.run(:db => db_name) do |r|
+      r.table_create(table_name, create_options.reject { |k,_| k.in? [:name, :write_acks] })
     end
-    env[:last_auto_create_table] = [database_name, table_name]
 
-    NoBrainer.with_database(database_name) do
-      NoBrainer.table_create(table_name, :primary_key => model.lookup_field_alias(model.pk_name))
+    if create_options[:write_acks] && create_options[:write_acks] != 'single'
+      NoBrainer.run(:db => db_name) do |r|
+        r.table(table_name).config().update(:write_acks => create_options[:write_acks])
+      end
     end
   rescue RuntimeError => e
     # We might have raced with another table create
-    raise unless e.message =~ /Table `#{database_name}\.#{table_name}` already exists/
+    raise unless e.message =~ /Table `#{db_name}\.#{table_name}` already exists/
   end
 end

data/lib/no_brainer/query_runner.rb

@@ -11,7 +11,7 @@ module NoBrainer::QueryRunner
   end
 
   autoload :Driver, :DatabaseOnDemand, :TableOnDemand, :WriteError,
-           :Reconnect, :Selection, :RunOptions, :Logger, :MissingIndex,
+           :Reconnect, :Selection, :RunOptions, :Profiler, :MissingIndex,
            :ConnectionLock
 
   class << self
@@ -28,11 +28,11 @@ module NoBrainer::QueryRunner
   # thread-safe, since require() is ran with a mutex.
   self.stack = ::Middleware::Builder.new do
     use RunOptions
-    use WriteError
     use MissingIndex
     use DatabaseOnDemand
     use TableOnDemand
-    use Logger
+    use Profiler
+    use WriteError
     use ConnectionLock
     use Reconnect
     use Driver

data/lib/no_brainer/railtie/database.rake

@@ -9,8 +9,18 @@ namespace :nobrainer do
     NoBrainer.sync_indexes(:verbose => true)
   end
 
-  task :sync_indexes_quiet => :environment do
-    NoBrainer.sync_indexes
+  desc 'Synchronize table configuration'
+  task :sync_table_config => :environment do
+    NoBrainer.sync_table_config(:verbose => true)
+  end
+
+  desc 'Synchronize indexes and table configuration'
+  task :sync_schema => :environment do
+    NoBrainer.sync_schema(:verbose => true)
+  end
+
+  task :sync_schema_quiet => :environment do
+    NoBrainer.sync_schema
   end
 
   desc 'Load seed data from db/seeds.rb'
@@ -18,8 +28,8 @@ namespace :nobrainer do
     Rails.application.load_seed
   end
 
-  desc 'Equivalent to :sync_indexes_quiet + :seed'
-  task :setup => [:sync_indexes_quiet, :seed]
+  desc 'Equivalent to :sync_schema_quiet + :seed'
+  task :setup => [:sync_schema_quiet, :seed]
 
   desc 'Equivalent to :drop + :setup'
   task :reset => [:drop, :setup]

data/lib/no_brainer/railtie.rb

@@ -26,20 +26,13 @@ class NoBrainer::Railtie < Rails::Railtie
   config.after_initialize do
     NoBrainer::Config.configure unless NoBrainer::Config.configured?
 
-    if defined?(ActiveRecord) && NoBrainer::Config.warn_on_active_record
-      STDERR.puts "[NoBrainer] ActiveRecord is loaded which is probably not what you want."
-      STDERR.puts "[NoBrainer] Follow the instructions on http://nobrainer.io/docs/configuration/#removing_activerecord"
-      STDERR.puts "[NoBrainer] Configure NoBrainer with 'config.warn_on_active_record = false' to disable with warning."
-    end
-
-    if defined?(Mongoid)
-      STDERR.puts "[NoBrainer] WARNING: Mongoid is loaded, and we conflict on the symbol decorations"
-      STDERR.puts "[NoBrainer] They are used in queries such as Model.where(:tags.in => ['fun', 'stuff'])"
-      STDERR.puts "[NoBrainer] This is a problem!"
-    end
-
     ActionDispatch::Reloader.to_prepare do
       NoBrainer::Loader.cleanup
     end
   end
+
+  ActiveSupport.on_load(:action_controller) do
+    require 'no_brainer/profiler/controller_runtime'
+    include NoBrainer::Profiler::ControllerRuntime
+  end
 end

data/lib/no_brainer/rql.rb

@@ -8,22 +8,25 @@ module NoBrainer::RQL
 
   def rql_proc_as_json(block)
     reset_lambda_var_counter
-    RethinkDB::RQL.new.new_func(&block).as_json
+    RethinkDB::Shim.load_json(
+      RethinkDB::Shim.dump_json(
+        RethinkDB::RQL.new.new_func(&block)))
   end
 
-  def is_write_query?(rql_query)
-    type_of(rql_query) == :write
+  def is_write_query?(rql)
+    type_of(rql) == :write
   end
 
-  def type_of(rql_query)
-    case rql_query.body.first
+  def type_of(rql)
+    case rql.is_a?(RethinkDB::RQL) && rql.body.is_a?(Array) && rql.body.first
     when UPDATE, DELETE, REPLACE, INSERT
       :write
-    when DB_CREATE, DB_DROP, DB_LIST, TABLE_CREATE, TABLE_DROP, TABLE_LIST, SYNC,
-         INDEX_CREATE, INDEX_DROP, INDEX_LIST, INDEX_STATUS, INDEX_WAIT
+    when DB_CREATE, DB_DROP, DB_LIST, TABLE_CREATE, TABLE_DROP, TABLE_LIST,
+         INDEX_CREATE, INDEX_DROP, INDEX_LIST, INDEX_STATUS, INDEX_WAIT, INDEX_RENAME,
+         CONFIG, STATUS, WAIT, RECONFIGURE, REBALANCE, SYNC
       :management
     else
-      # XXX Not sure if that's correct, but we'll be happy for logging colors.
+      # XXX Not necessarily correct, but we'll be happy for logging colors.
       :read
     end
   end

data/lib/no_brainer/symbol_decoration.rb

@@ -0,0 +1,11 @@
+module NoBrainer::SymbolDecoration
+  NON_CHAINABLE_OPERATORS = %w(in eq gt ge gte lt le lte defined undefined near intersects include).map(&:to_sym)
+  CHAINABLE_OPERATORS = %w(not any all).map(&:to_sym)
+  OPERATORS = CHAINABLE_OPERATORS + NON_CHAINABLE_OPERATORS
+
+  def self.hook
+    require 'symbol_decoration'
+    Symbol::Decoration.register(*NON_CHAINABLE_OPERATORS)
+    Symbol::Decoration.register(*CHAINABLE_OPERATORS, :chainable => true)
+  end
+end

data/lib/no_brainer/system/cluster_config.rb

@@ -0,0 +1,5 @@
+class NoBrainer::System::ClusterConfig
+  include NoBrainer::System::Document
+
+  field :auth_key
+end

data/lib/no_brainer/system/db_config.rb

@@ -0,0 +1,5 @@
+class NoBrainer::System::DBConfig
+  include NoBrainer::System::Document
+
+  field :name
+end

data/lib/no_brainer/system/document.rb

@@ -0,0 +1,24 @@
+module NoBrainer::System::Document
+  extend ActiveSupport::Concern
+
+  include NoBrainer::Document
+  include NoBrainer::Document::DynamicAttributes
+
+  included do
+    disable_perf_warnings
+
+    field :id, :type => Object, :default => nil, :primary_key => true
+
+    default_scope { without_ordering }
+  end
+
+  module ClassMethods
+    def table_name
+      table_config_options[:name] || name.split('::').last.underscore
+    end
+
+    def rql_table
+      RethinkDB::RQL.new.db('rethinkdb').table(table_name)
+    end
+  end
+end

data/lib/no_brainer/system/issue.rb

@@ -0,0 +1,10 @@
+class NoBrainer::System::Issue
+  include NoBrainer::System::Document
+
+  table_config :name => 'current_issues'
+
+  field :type
+  field :critical
+  field :info
+  field :description
+end

data/lib/no_brainer/system/job.rb

@@ -0,0 +1,10 @@
+class NoBrainer::System::Job
+  include NoBrainer::System::Document
+
+  table_config :name => 'jobs'
+
+  field :duration_sec
+  field :info
+  field :servers
+  field :type
+end

data/lib/no_brainer/system/log.rb

@@ -0,0 +1,11 @@
+class NoBrainer::System::Log
+  include NoBrainer::System::Document
+
+  table_config :name => 'logs'
+
+  field :level
+  field :message
+  field :server
+  field :timestamp
+  field :uptime
+end

data/lib/no_brainer/system/server_config.rb

@@ -0,0 +1,7 @@
+class NoBrainer::System::ServerConfig
+  include NoBrainer::System::Document
+
+  field :name
+  field :cache_size_mb
+  field :tags
+end

data/lib/no_brainer/system/server_status.rb

@@ -0,0 +1,9 @@
+class NoBrainer::System::ServerStatus
+  include NoBrainer::System::Document
+
+  field :name
+  field :status
+  field :connection
+  field :network
+  field :process
+end

data/lib/no_brainer/system/stat.rb

@@ -0,0 +1,11 @@
+class NoBrainer::System::Stat
+  include NoBrainer::System::Document
+
+  table_config :name => 'stats'
+
+  field :server
+  field :db
+  field :table
+  field :query_engine
+  field :storage_engine
+end

data/lib/no_brainer/system/table_config.rb

@@ -0,0 +1,10 @@
+class NoBrainer::System::TableConfig
+  include NoBrainer::System::Document
+
+  field :db
+  field :name
+  field :durability
+  field :primary_key
+  field :shards
+  field :write_acks
+end

data/lib/no_brainer/system/table_status.rb

@@ -0,0 +1,8 @@
+class NoBrainer::System::TableStatus
+  include NoBrainer::System::Document
+
+  field :db
+  field :name
+  field :status
+  field :shards
+end

data/lib/no_brainer/system.rb

@@ -0,0 +1,17 @@
+module NoBrainer::System
+  extend NoBrainer::Autoload
+  autoload :Document, :ClusterConfig, :DBConfig,
+           :Issue, :Job, :Log, :ServerConfig, :ServerStatus,
+           :Stat, :TableConfig, :TableStatus
+
+  # A few shortcuts to make user's life easier
+  def self.const_missing(const_name)
+    mapping = {:CurrentIssues => :Issue,
+               :CurrentIssue  => :Issue,
+               :Issues        => :Issue,
+               :Jobs          => :Job,
+               :Logs          => :Log,
+               :Stats         => :Stat}
+    const_get(mapping[const_name] || const_name)
+  end
+end

data/lib/nobrainer.rb

@@ -1,10 +1,11 @@
 require 'set'
 require 'active_support'
+require 'active_model'
 require 'thread'
 %w(module/delegation module/attribute_accessors module/introspection
    class/attribute object/blank object/inclusion object/deep_dup
    object/try hash/keys hash/indifferent_access hash/reverse_merge
-   hash/deep_merge array/extract_options)
+   hash/deep_merge hash/slice array/extract_options)
     .each { |dep| require "active_support/core_ext/#{dep}" }
 
 module NoBrainer
@@ -13,21 +14,24 @@ module NoBrainer
 
   # We eager load things that could be loaded when handling the first web request.
   # Code that is loaded through the DSL of NoBrainer should not be eager loaded.
-  autoload :Document, :IndexManager, :Loader, :Fork, :Geo, :Lock
-  eager_autoload :Config, :Connection, :ConnectionManager,  :Error,
-                 :QueryRunner, :Criteria, :RQL
+  autoload :Document, :IndexManager, :Loader, :Fork, :Geo, :SymbolDecoration
+  eager_autoload :Config, :Connection, :ConnectionManager, :Error,
+                 :QueryRunner, :Criteria, :RQL, :Lock, :Profiler, :System
 
   class << self
     delegate :connection, :disconnect, :to => 'NoBrainer::ConnectionManager'
 
-    delegate :db_create, :db_drop, :db_list,
-             :table_create, :table_drop, :table_list,
-             :drop!, :purge!, :to => :connection
+    delegate :drop!, :purge!, :default_db, :current_db, :to => :connection
 
-    delegate :configure, :logger,   :to => 'NoBrainer::Config'
-    delegate :run,                  :to => 'NoBrainer::QueryRunner'
-    delegate :sync_indexes,         :to => 'NoBrainer::Document::Index::Synchronizer'
-    delegate :with, :with_database, :to => 'NoBrainer::QueryRunner::RunOptions'
+    delegate :configure, :logger,             :to => 'NoBrainer::Config'
+    delegate :run,                            :to => 'NoBrainer::QueryRunner'
+    delegate :current_run_options, :run_with, :to => 'NoBrainer::QueryRunner::RunOptions'
+
+    delegate :with, :with_database, :to => 'NoBrainer::QueryRunner::RunOptions' # deprecated
+
+    delegate :sync_indexes, :sync_table_config, :sync_schema, :rebalance, :to => 'NoBrainer::Document::TableConfig'
+
+    delegate :eager_load, :to => 'NoBrainer::Document::Association::EagerLoader'
 
     def jruby?
       RUBY_PLATFORM == 'java'
@@ -35,6 +39,7 @@ module NoBrainer
   end
 
   Fork.hook unless jruby?
+  SymbolDecoration.hook
 end
 
 ActiveSupport.on_load(:i18n) do

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

@@ -0,0 +1,48 @@
+require "rails/generators/nobrainer/namespace_fix"
+require 'rails/generators/base'
+
+module NoBrainer::Generators
+  class InstallGenerator < Rails::Generators::Base
+    extend NoBrainer::Generators::NamespaceFix
+    source_root File.expand_path("../../templates", __FILE__)
+
+    desc "Disable ActiveRecord and generates ./config/initializers/nobrainer.rb"
+
+    class RequireProxy
+      attr_accessor :required_paths
+      def initialize
+        self.required_paths = []
+      end
+
+      def require(path)
+        self.required_paths << path
+      end
+
+      def resolve_require_path(path)
+        $:.map { |dir| File.join(dir, path) }.detect { |f| File.exists?(f) }
+      end
+    end
+
+    def expand_require_rails_all
+      require_proxy = RequireProxy.new
+      rails_all_file = require_proxy.resolve_require_path('rails/all.rb')
+      require_proxy.instance_eval(File.read(rails_all_file))
+
+      gsub_file('config/application.rb', %r(^require 'rails/all'$)) do
+        require_proxy.required_paths.map { |f| "require '#{f}'" }.join("\n")
+      end
+    end
+
+    def remove_active_record
+      (Dir['config/environments/*'] + ['config/application.rb']).each do |config_file|
+        comment_lines(config_file, /active_record/)
+      end
+      remove_file('config/database.yml')
+    end
+
+
+    def copy_initializer
+      template('nobrainer.rb', 'config/initializers/nobrainer.rb')
+    end
+  end
+end

data/lib/rails/generators/nobrainer/{model/model_generator.rb → model_generator.rb}

@@ -1,7 +1,11 @@
-require "rails/generators/nobrainer"
+require "rails/generators/nobrainer/namespace_fix"
+require 'rails/generators/named_base'
 
 module NoBrainer::Generators
-  class ModelGenerator < Base
+  class ModelGenerator < Rails::Generators::NamedBase
+    extend NoBrainer::Generators::NamespaceFix
+    source_root File.expand_path("../../templates", __FILE__)
+
     argument(:attributes, :type => :array, default: [],
              banner: "field[:type][:index] ... field[:type][:index]")
 
@@ -10,7 +14,7 @@ module NoBrainer::Generators
     class_option :parent, :type => :string, :desc => "The parent class for the generated model"
 
     def create_model_file
-      template "model.rb.tt", File.join("app/models", class_path, "#{file_name}.rb")
+      template "model.rb", File.join("app", "models", class_path, "#{file_name}.rb")
     end
 
     hook_for :test_framework

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

@@ -0,0 +1,15 @@
+module NoBrainer::Generators
+  module NamespaceFix
+    def base_name
+      'nobrainer'
+    end
+
+    def base_root
+      File.dirname(__FILE__)
+    end
+
+    def namespace
+      super.gsub(/no_brainer/, 'nobrainer')
+    end
+  end
+end

data/lib/rails/generators/{nobrainer/model/templates/model.rb.tt → templates/model.rb}

@@ -7,7 +7,7 @@ class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent]
 <% end -%>
 <% attributes.reject(&:reference?).each do |attribute| -%>
   field :<%= attribute.name -%>
-<%= puts attribute; ", :type => #{attribute.type.to_s.classify}" if attribute.type != :object -%>
+<%= ", :type => #{attribute.type.to_s.classify}" if attribute.type != :object -%>
 <%= ", :index => true" if attribute.has_index? %>
 <% end -%>
 <% attributes.select(&:reference?).each do |attribute| -%>

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

@@ -0,0 +1,101 @@
+NoBrainer.configure do |config|
+  # app_name is the name of your application in lowercase.
+  # When using Rails, the application name is automatically inferred.
+  # config.app_name = config.default_app_name
+
+  # environment defaults to Rails.env for Rails apps or to the environment
+  # variables RUBY_ENV, RAILS_ENV, RACK_ENV, or :production.
+  # config.environment = config.default_environment
+
+  # rethinkdb_urls specifies the RethinkDB database connection urls.
+  # You may specify multiple urls to provide fault tolerance capabilities.
+  # When left unspecified, NoBrainer picks a database connection by default.
+  # The default is to use localhost, with a database name matching the
+  # application name and the environment.
+  # NoBrainer also reads environment variables when defined:
+  # * RETHINKDB_URL, RDB_URL
+  # * RETHINKDB_HOST, RETHINKDB_PORT, RETHINKDB_DB, RETHINKDB_AUTH
+  # * RDB_HOST, RDB_PORT, RDB_DB, RDB_AUTH
+  # config.rethinkdb_urls = [config.default_rethinkdb_url]
+
+  # ssl_options may be set to {:ca_certs => '/path/to/ca.crt'} to establish
+  # an SSL connection to the RethinkDB servers.
+  # config.ssl_options = nil
+
+  # NoBrainer uses logger to emit debugging information.
+  # The default logger is the Rails logger if run with Rails,
+  # otherwise Logger.new(STDERR) with a WARN level.
+  # If the logger is configured with a DEBUG level,
+  # then each database query is emitted.
+  # config.logger = config.default_logger
+
+  # NoBrainer will colorize the queries if colorize_logger is true.
+  # Specifically, NoBrainer will colorize management RQL queries in yellow,
+  # write queries in red and read queries in green.
+  # config.colorize_logger = true
+
+  # You probably do not want to use both NoBrainer and ActiveRecord in your
+  # application. NoBrainer will emit a warning if you do so.
+  # You can turn off the warning if you want to use both.
+  # config.warn_on_active_record = true
+
+  # When the network connection is lost, NoBrainer can retry running a given
+  # query a few times before giving up. Note that this can be a problem with
+  # non idempotent write queries such as increments.
+  # Setting it to 0 disable retries during reconnections.
+  # The default is 1 for development or test environment, otherwise 15.
+  # config.max_retries_on_connection_failure = \
+  #   config.default_max_retries_on_connection_failure
+
+  # Configures the durability for database writes.
+  # The default is :soft for development or test environment, otherwise :hard.
+  # config.durability = config.default_durability
+
+  # Configures the default table configuration options. These values are
+  # reflected to the database when running `rake nobrainer:sync_schema'.
+  # config.table_options = { :shards => 1, :replicas => 1, :write_acks => :majority }
+
+  # Persisted Strings have a configurable maximum length. To get rid of the
+  # length validation, you may use the Text type instead.
+  # config.max_string_length = 255
+
+  # user_timezone can be configured with :utc, :local, or :unchanged.
+  # When reading an attribute from a model which type is Time, the timezone
+  # of that time is translated according to this setting.
+  # config.user_timezone = :local
+
+  # db_timezone can be configured with :utc, :local, or :unchanged.
+  # When writting to the database, the timezone of Time attributes are
+  # translated according to this setting.
+  # config.db_timezone = :utc
+
+  # Default options used when compiling geo queries.
+  # config.geo_options => { :geo_system => 'WGS84', :unit => 'm' }
+
+  # Configures which mechanism to use in order to perform non-racy uniqueness
+  # validations. More about this behavior in the Distributed Locks section.
+  # config.distributed_lock_class = "NoBrainer::Lock"
+
+  # Configures the default timing lock options.
+  # config.lock_options = { :expire => 60, :timeout => 10 }
+
+  # Instead of using a single connection to the database, You can tell
+  # NoBrainer to spin up a new connection for each thread. This is
+  # useful for multi-threading usage such as Sidekiq.
+  # Call NoBrainer.disconnect before a thread exits, otherwise you will have
+  # a resource leak, and you will run out of connections.
+  # Note that this is solution is temporary, until we get a connection pool.
+  # config.per_thread_connection = false
+
+  # The machine id is used to generate primary keys. The default one is seeded
+  # with the machine IP with Socket.gethostname.
+  # The env variable MACHINE_ID can also be used to set the machine id.
+  # When using distinct machine_id, then primary keys are guaranteed to be
+  # generated without conflicts.
+  # config.machine_id = config.default_machine_id
+
+  # Criteria cache elements. For example, the result of a has_many association
+  # 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
+end