elastics 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5c6528a83756461e3f88a64c932e6f6cd4a572e
-  data.tar.gz: 329c63ad74333cee9dc57581ca8ac626973dea3b
+  metadata.gz: ca7add0bf62591b992bdcbb03cf08461cf208204
+  data.tar.gz: 5f2b845c2cf49a89e6f4414dfad2dd505ed56784
 SHA512:
-  metadata.gz: aba73c791bb368035b51ed5d93994fa27648c442f77ed7992749b5bb5ee5ee823a17e33d5449d0d8a1f293dd830ff01501405287ca1dc563df644c3bb3da68ba
-  data.tar.gz: d687176c8013f6196d0ebc0340aaa6e194e5719b700fdbb688159ca2ca6ffda3694e144e0b55c064fcb63b629299288121b9dbd25ba61876318092089360cafa
+  metadata.gz: da3920ea1f157297b6c3e5fea2b7ead3620493fb887ee34bd6191b8428ab74763fb324246be193fbd5e2fc32268f7f61331680a02f087d6ce3c619d9d7da1820
+  data.tar.gz: 262e2e0efec270bed5eac991e706298220bf67f5024efd6ae99782d94efb86380c95bf40bcc9dc2779e423205d6c00441a9b72968921894d3bd5fb3869034cab

data/.travis.yml

@@ -3,6 +3,8 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.4
+  - jruby-19mode
+  - jruby-head
 services:
   - elasticsearch
 notifications:

data/Gemfile

@@ -1,3 +1,9 @@
 source 'https://rubygems.org'
 
 gemspec
+
+group :development do
+  gem 'pry', '~> 0.10.1'
+  gem 'pry-byebug', '~> 2.0.0', platforms: [:mri_20, :mri_21]
+  gem 'pry-coolline', '~> 0.2.5'
+end

data/README.md

@@ -32,8 +32,6 @@ client = Elastics::Client.new(options)
 #   :host   - hostname with port or array with hosts (default 127.0.0.1:9200)
 #   :index  - (default index)
 #   :type   - (default type)
-#   :connect_timeout    - timeout to mark the host as dead in cluster-mode (default 10)
-#   :resurrect_timeout  - timeout to mark dead host as alive in cluster-mode (default 10)
 
 # basic request
 client.request(params)
@@ -70,7 +68,21 @@ client.bulk(params) do |bulk|
 end
 ```
 
-When using cluster-mode you should also install `gem 'thread_safe'`.
+### Models
+Most of ActiveRecord integration functionality is available for plain ruby.
+
+```ruby
+class User
+  include Elastics::Model
+
+  # set connection config, check 'configure section' for available options
+  self.elastics_config = {host: 'hostname:port'}
+  # set index base and version manager will manage aliases
+  self.elastics_index_base = 'user'
+  self.elastics_type_name = 'user'
+end
+```
+Check out available [HelperMethods](https://github.com/printercu/elastics-rb/blob/master/lib/elastics/model/helper_methods.rb).
 
 ### ActiveRecord
 
@@ -91,8 +103,13 @@ User.elastics_params # hash with index & type values for the model
 User.request_elastics(params) # performs request merging params with elastics_params
 User.search_elastics(data)
 # Returns Elastics::ActiveRecord::SearchResult object with some useful methods
+
+# Indexing on create/update can be skipped with skip_elastics
+User.skip_elastics { users.each { |x| x.update_attributes(smth: 'not indexed') } }
+user.skip_elastics { user.update_attributes(smth: 'not indexed') }
 ```
-Check out [HelperMethods](https://github.com/printercu/elastics-rb/blob/master/lib/elastics/active_record/helper_methods.rb)
+Check out [Model::HelperMethods](https://github.com/printercu/elastics-rb/blob/master/lib/elastics/model/helper_methods.rb)
+and [AR::HelperMethods](https://github.com/printercu/elastics-rb/blob/master/lib/elastics/active_record/helper_methods.rb)
 for more information.
 
 #### Configure
@@ -171,8 +188,7 @@ task :environment do
 end
 ```
 
-Also you need to install `active_support` & require
-`active_support/core_ext/object` to be able to run tasks.
+Also you need to install `active_support` to be able to run tasks.
 
 ### Auto refresh index
 Add `Elastics::AutoRefresh.enable!` to your test helper,
@@ -189,6 +205,48 @@ Elastics::AutoRefresh.disable! { Model.reindex_elastics }
 Model.refresh_elastics
 ```
 
+### Instrumentation
+Instrumentation works out of box in rails. For pure ruby there is only
+ActiveSupport version (remember to install gem).
+
+```ruby
+# Activate instrumentation (no need for rails)
+Elastics::Instrumentation::ActiveSupport.install
+
+# Activate body prettifier (off by default)
+Elastics::Instrumentation.body_prettifier = true
+# can be
+#   true - JSON.pretty_generate
+#   :ap  - awesome_print
+#   :pp  - pretty_print
+#   Proc - ->(str) { your_prettifier(str) }
+```
+
+### Connecting to cluster
+When you pass array in `:host` option to initializer, client will work in cluster mode.
+There are some options for this mode:
+- `:connect_timeout`    - timeout to mark the host as dead in cluster-mode (default 10)
+- `:resurrect_timeout`  - timeout to mark dead host as alive in cluster-mode (default 60)
+- `:discover`           - enable nodes discovering
+
+In plain ruby you should also install `thread_safe` gem.
+
+##### Note about nodes discovering
+Client will perform requests to discover nodes with enabled http module. After
+discovering hosts will be overwritten with discovered ones.
+
+`discover: true` will keep you from editing config too frequently,
+but keep in mind that you should set enough hosts explicitly, so that discover
+will be able to continue if some of hosts are down.
+Also this is performed automaticaly only once, when client is initialized.
+It will not track nodes that go online after client was instantiated. Anyway you
+still can call `.discover_cluster` whenever you want, or just restart app when
+you add more nodes.
+
+### Thread-safety
+Elastics designed to be thread-safe. It should be ok to have single client instance
+for the whole application.
+
 ### Use with capistrano
 Add following lines to your `deploy.rb` and all rake tasks will be available in cap.
 

data/lib/elastics.rb

@@ -4,21 +4,13 @@ module Elastics
 
   require 'elastics/client'
 
-  autoload :AutoRefresh,    'elastics/auto_refresh'
-  autoload :Tasks,          'elastics/tasks'
-  autoload :QueryHelper,    'elastics/query_helper'
-  autoload :Result,         'elastics/result'
-  autoload :VersionManager, 'elastics/version_manager'
-
-  class << self
-    attr_reader :models
-
-    def reset_models
-      @models = []
-    end
-  end
-
-  reset_models
+  autoload :AutoRefresh,      'elastics/auto_refresh'
+  autoload :Instrumentation,  'elastics/instrumentation'
+  autoload :Model,            'elastics/model'
+  autoload :QueryHelper,      'elastics/query_helper'
+  autoload :Result,           'elastics/result'
+  autoload :Tasks,            'elastics/tasks'
+  autoload :VersionManager,   'elastics/version_manager'
 end
 
 require 'elastics/railtie' if defined?(Rails)

data/lib/elastics/active_record.rb

@@ -5,33 +5,21 @@ module Elastics
     autoload :SearchResult
     autoload :ModelSchema
     autoload :HelperMethods
-    autoload :Instrumentation
-    autoload :LogSubscriber, 'elastics/active_record/instrumentation'
 
     class << self
       def install
         ::ActiveRecord::Base.extend self
-        Instrumentation.install
+        Instrumentation::ActiveSupport.install
       end
     end
 
+    include Model::Connection
+
     def elastics_config
       @elastics_config ||= connection_config[:elastics].try!(:with_indifferent_access) ||
         raise('No elastics configuration in database.yml')
     end
 
-    def elastics
-      @elastics ||= Client.new elastics_config.slice(:host, :port)
-    end
-
-    # Don't memoize to GC it after initialization
-    def elastics_version_manager
-      VersionManager.new(elastics, elastics_config.slice(
-        :service_index,
-        :index_prefix,
-      ))
-    end
-
     def indexed_with_elastics(options = {})
       options = {
         hooks: [:update, :destroy],
@@ -39,13 +27,22 @@ module Elastics
 
       extend ModelSchema
       include HelperMethods
+      extend Model::Tracking
 
       self.elastics_index_base  = options[:index] if options[:index]
       self.elastics_type_name   = options[:type]  if options[:type]
 
-      hooks = options[:hooks]
-      after_commit :index_elastics, on: [:create, :update] if hooks.include?(:update)
-      after_commit :delete_elastics, on: [:destroy] if hooks.include?(:destroy)
+      install_elastics_hooks(options[:hooks])
     end
+
+    private
+      def install_elastics_hooks(hooks)
+        if hooks.include?(:update)
+          after_commit :index_elastics, on: [:create, :update], unless: :skip_elastics?
+        end
+        if hooks.include?(:destroy)
+          after_commit :delete_elastics, on: [:destroy], unless: :skip_elastics?
+        end
+      end
   end
 end

data/lib/elastics/active_record/helper_methods.rb

@@ -3,27 +3,13 @@ module Elastics
     module HelperMethods
       extend ActiveSupport::Concern
 
-      included do
-        alias_method :to_elastics, :as_json unless instance_methods.include?(:to_elastics)
+      def self.append_features(base)
+        base.send :include, Model::HelperMethods
+        base.send :include, Model::Skipping
+        super
       end
 
       module ClassMethods
-        def elastics_params
-          {
-            index:  elastics_index_name,
-            type:   elastics_type_name,
-            model:  self,
-          }
-        end
-
-        def request_elastics(params)
-          elastics.request(elastics_params.merge!(params))
-        end
-
-        def bulk_elastics(params = {}, &block)
-          elastics.bulk(elastics_params.merge!(params), &block)
-        end
-
         def search_elastics(data = {}, options = {})
           request = {
             id:   :_search,
@@ -46,11 +32,7 @@ module Elastics
 
         def index_all_elastics(*args)
           find_in_batches(*args) do |batch|
-            bulk_elastics do |bulk|
-              batch.each do |record|
-                bulk.index record.id, record.to_elastics
-              end
-            end
+            index_batch_elastics(batch)
           end
         end
 
@@ -71,27 +53,6 @@ module Elastics
           end
           scope.index_all_elastics(options)
         end
-
-        def refresh_elastics
-          request_elastics(method: :post, type: nil, id: :_refresh)
-        end
-      end
-
-      def index_elastics
-        self.class.request_elastics(method: :post, id: id, body: to_elastics)
-      end
-
-      def update_elastics(data)
-        self.class.request_elastics(method: :post, id: "#{id}/_update", body: data)
-      end
-
-      def update_elastics_doc(fields)
-        update_elastics(doc: fields)
-      end
-
-      def delete_elastics
-        self.class.request_elastics(method: :delete, id: id)
-      rescue NotFound
       end
     end
   end

data/lib/elastics/active_record/model_schema.rb

@@ -1,22 +1,7 @@
 module Elastics
   module ActiveRecord
     module ModelSchema
-      class << self
-        def track_model(model)
-          Elastics.models << model unless model.abstract_class?
-        end
-
-        def extended(base)
-          track_model(base)
-        end
-      end
-
-      attr_writer :elastics_index_base, :elastics_type_name
-
-      def elastics_index_name
-        reset_elastics_index_name unless defined?(@elastics_index_name)
-        @elastics_index_name
-      end
+      include Model::Schema
 
       def elastics_type_name
         @elastics_type_name ||= model_name.to_s.demodulize.underscore.singularize
@@ -28,16 +13,8 @@ module Elastics
         end
       end
 
-      def compute_elastics_index_name
-        elastics_version_manager.index_name(elastics_index_base)
-      end
-
-      def elastics_index_base
-        @elastics_index_base || elastics_config[:index] || elastics_type_name
-      end
-
-      def inherited(base)
-        super.tap { ::Elastics::ActiveRecord::ModelSchema.track_model(base) }
+      def track_elastics_model?
+        !abstract_class?
       end
     end
   end

data/lib/elastics/client.rb

@@ -14,15 +14,15 @@ module Elastics
     attr_reader :client
 
     def initialize(defaults = {})
+      @index  = defaults[:index]
+      @type   = defaults[:type]
+      @client = HTTPClient.new
       if defaults[:host].is_a?(Array)
         extend Cluster
         initialize_cluster(defaults)
       else
         @host = defaults[:host] || '127.0.0.1:9200'
       end
-      @index  = defaults[:index]
-      @type   = defaults[:type]
-      @client = HTTPClient.new
     end
 
     def debug!(dev = STDOUT)
@@ -133,7 +133,7 @@ module Elastics
       # You probably don't want to use this method directly.
       def http_request(method, path, query, body, params = nil, host = @host)
         uri = "http://#{host}#{path}"
-        @client.request(method, uri, query, body, HEADERS)
+        client.request(method, uri, query, body, HEADERS)
       end
   end
 end

data/lib/elastics/client/cluster.rb

@@ -7,14 +7,27 @@ module Elastics
     module Cluster
       class NoAliveHosts < Error; end
 
+      def discover_cluster
+        # `nothing` allows not to fetch all unnecessary data
+        discovered = request(index: '_nodes', type: '_all', id: 'nothing')['nodes'].
+          map { |id, node|
+            match = node['http_address'].match(/inet\[.*?\/([\da-f.:]+)/i)
+            match && match[1]
+          }.compact
+        @cluster_mutex.synchronize do
+          @hosts.clear.concat(discovered - @dead_hosts.keys)
+        end
+      end
+
       private
         def initialize_cluster(defaults)
           @hosts = ThreadSafe::Array.new defaults[:host]
           @dead_hosts = ThreadSafe::Hash.new
           @connect_timeout = defaults[:connect_timeout] || 10
-          @resurrect_timeout = defaults[:resurrect_timeout] || 10
+          @resurrect_timeout = defaults[:resurrect_timeout] || 60
           @current_host_n = 0
           @cluster_mutex = Mutex.new
+          discover_cluster if defaults[:discover]
         end
 
         def http_request(method, path, query, body, params = nil)
@@ -27,44 +40,46 @@ module Elastics
           retry
         end
 
-      # TODO: check Enumerable#cycle for thread-safety and use it if possible
-      def next_cluster_host
-        if @resurrect_at
-          time = Time.now.to_i
-          resurrect_cluster(time) if @resurrect_at <= time
-        end
-        host_n = @current_host_n
-        loop do
-          host = @hosts[host_n]
-          if !host
-            raise NoAliveHosts if host_n == 0
-            host_n = 0
-          else
-            @current_host_n = host_n + 1
-            return host
+        # Very simple implementation. It may skip some hosts on current cycle
+        # when other is marked as dead. This should not be a problem.
+        # TODO: check Enumerable#cycle for thread-safety and use it if possible
+        def next_cluster_host
+          if @resurrect_at
+            time = Time.now.to_i
+            resurrect_cluster(time) if @resurrect_at <= time
+          end
+          host_n = @current_host_n
+          loop do
+            host = @hosts[host_n]
+            if !host
+              raise NoAliveHosts if host_n == 0
+              host_n = 0
+            else
+              @current_host_n = host_n + 1
+              return host
+            end
           end
         end
-      end
 
-      def resurrect_cluster(time = Time.now.to_i)
-        @cluster_mutex.synchronize do
-          @dead_hosts.delete_if do |host, resurrect_at|
-            # skip the rest because values are sorted
-            if time < resurrect_at
-              @resurrect_at = resurrect_at
-              break
+        def resurrect_cluster(time = Time.now.to_i)
+          @cluster_mutex.synchronize do
+            @dead_hosts.delete_if do |host, resurrect_at|
+              # skip the rest because values are sorted
+              if time < resurrect_at
+                @resurrect_at = resurrect_at
+                break
+              end
+              @hosts << host
             end
-            @hosts << host
           end
         end
-      end
 
-      def add_dead_host(host, resurrect_at = nil)
-        resurrect_at ||= Time.now.to_i + @resurrect_timeout
-        @hosts.delete(host)
-        @dead_hosts[host] = resurrect_at
-        @resurrect_at ||= resurrect_at
-      end
+        def add_dead_host(host, resurrect_at = nil)
+          resurrect_at ||= Time.now.to_i + @resurrect_timeout
+          @hosts.delete(host)
+          @dead_hosts[host] = resurrect_at
+          @resurrect_at ||= resurrect_at
+        end
     end
   end
 end

data/lib/elastics/instrumentation.rb

@@ -0,0 +1,38 @@
+module Elastics
+  module Instrumentation
+    autoload :ActiveSupport, 'elastics/instrumentation/active_support'
+
+    PRETTIFIERS = {
+      ap:     ->(str) { prettify_json(str, &:awesome_inspect) },
+      pp:     ->(str) { prettify_json(str, &:pretty_inspect) },
+      true => ->(str) { prettify_json(str, &JSON.method(:pretty_generate)) },
+    }
+
+    class << self
+      def body_prettifier=(value)
+        @body_prettifier = case value
+        when Proc, nil, false then value
+        else PRETTIFIERS[value] or raise 'Invalid prettifier'
+        end
+      end
+
+      def prettify_body(str)
+        if @body_prettifier
+          @body_prettifier.call(str)
+        else
+          str
+        end
+      end
+
+      def prettify_json(str, &block)
+        data = [JSON.parse(str)] rescue nil
+        data ||= str.split("\n").map { |x| JSON.parse(x) } rescue nil
+        if data
+          data.map(&block).join("\n")
+        else
+          str
+        end
+      end
+    end
+  end
+end

data/lib/elastics/instrumentation/active_support.rb

@@ -0,0 +1,70 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/log_subscriber'
+require 'active_support/notifications'
+
+module Elastics
+  module Instrumentation
+    module ActiveSupport
+      class << self
+        def install
+          if Client.respond_to?(:prepend)
+            Client.prepend self
+          else
+            Client.send :include, Ruby19Fallback
+          end
+          LogSubscriber.attach_to :elastics
+        end
+      end
+
+      def http_request(*args)
+        ::ActiveSupport::Notifications.instrument 'http_request.elastics', args: args do
+          super
+        end
+      end
+
+      # old rubies support
+      module Ruby19Fallback
+        def self.included(base)
+          base.alias_method_chain :http_request, :as_instrumentation
+        end
+
+        def http_request_with_as_instrumentation(*args)
+          ::ActiveSupport::Notifications.instrument 'http_request.elastics', args: args do
+            http_request_without_as_instrumentation(*args)
+          end
+        end
+      end
+
+      class LogSubscriber < ::ActiveSupport::LogSubscriber
+        def http_request(event)
+          return unless logger.debug?
+
+          payload = event.payload[:args]
+          method, path, query, body, params = payload
+          path = '/' if path.blank?
+          path << "?#{query.to_param}" if query.present?
+          model = params[:model]
+
+          name = ""
+          name << "#{model.name} " if model
+          name << "elastics (#{event.duration.round(1)}ms)"
+          request = "#{method.to_s.upcase} #{path}"
+          request << " #{Instrumentation.prettify_body(body)}" if body.present?
+
+          if odd?
+            name    = color(name, ::ActiveSupport::LogSubscriber::CYAN, true)
+            request = color(request, nil, true)
+          else
+            name = color(name, ::ActiveSupport::LogSubscriber::MAGENTA, true)
+          end
+
+          debug "  #{name}  #{request}"
+        end
+
+        def odd?
+          @odd = !@odd
+        end
+      end
+    end
+  end
+end

data/lib/elastics/model.rb

@@ -0,0 +1,18 @@
+module Elastics
+  module Model
+    autoload :Connection,     'elastics/model/connection'
+    autoload :HelperMethods,  'elastics/model/helper_methods'
+    autoload :Schema,         'elastics/model/schema'
+    autoload :Skipping,       'elastics/model/skipping'
+
+    require 'elastics/model/tracking'
+
+    def self.included(base)
+      base.extend Connection
+      base.extend Schema
+      base.extend Tracking
+      base.send :include, HelperMethods
+      base.send :include, Skipping
+    end
+  end
+end

data/lib/elastics/model/connection.rb

@@ -0,0 +1,19 @@
+module Elastics
+  module Model
+    module Connection
+      attr_accessor :elastics_config
+
+      def elastics
+        @elastics ||= Client.new elastics_config.slice(:host)
+      end
+
+      # Don't memoize to GC it after initialization
+      def elastics_version_manager
+        VersionManager.new(elastics, elastics_config.slice(
+          :service_index,
+          :index_prefix,
+        ))
+      end
+    end
+  end
+end

data/lib/elastics/model/helper_methods.rb

@@ -0,0 +1,67 @@
+module Elastics
+  module Model
+    module HelperMethods
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+
+          # don't override to_elastics method, if it already exists
+          if !instance_methods.include?(:to_elastics) && instance_methods.include?(:as_json)
+            alias_method :to_elastics, :as_json
+          end
+        end
+      end
+
+      module ClassMethods
+        def elastics_params
+          {
+            index:  elastics_index_name,
+            type:   elastics_type_name,
+            model:  self,
+          }
+        end
+
+        def request_elastics(params)
+          elastics.request(elastics_params.merge!(params))
+        end
+
+        def bulk_elastics(params = {}, &block)
+          elastics.bulk(elastics_params.merge!(params), &block)
+        end
+
+        def refresh_elastics
+          request_elastics(method: :post, type: nil, id: :_refresh)
+        end
+
+        def index_batch_elastics(batch)
+          bulk_elastics do |bulk|
+            batch.each do |record|
+              bulk.index record.id, record.to_elastics
+            end
+          end
+        end
+
+        def reindex_elastics(options = {})
+          raise 'Not implemented'
+        end
+      end
+
+      def index_elastics
+        self.class.request_elastics(method: :post, id: id, body: to_elastics)
+      end
+
+      def update_elastics(data)
+        self.class.request_elastics(method: :post, id: "#{id}/_update", body: data)
+      end
+
+      def update_elastics_doc(fields)
+        update_elastics(doc: fields)
+      end
+
+      def delete_elastics
+        self.class.request_elastics(method: :delete, id: id)
+      rescue NotFound
+      end
+    end
+  end
+end

data/lib/elastics/model/schema.rb

@@ -0,0 +1,32 @@
+module Elastics
+  module Model
+    module Schema
+      attr_writer :elastics_index_base, :elastics_type_name
+
+      def elastics_index_name
+        reset_elastics_index_name unless defined?(@elastics_index_name)
+        @elastics_index_name
+      end
+
+      def elastics_type_name
+        @elastics_type_name ||= name.split('::').last.downcase
+      end
+
+      def reset_elastics_index_name
+        @elastics_index_name = if superclass.respond_to?(:elastics_index_name)
+          superclass.elastics_index_name
+        else
+          compute_elastics_index_name
+        end
+      end
+
+      def compute_elastics_index_name
+        elastics_version_manager.index_name(elastics_index_base)
+      end
+
+      def elastics_index_base
+        @elastics_index_base || elastics_config[:index] || elastics_type_name
+      end
+    end
+  end
+end

data/lib/elastics/model/skipping.rb

@@ -0,0 +1,42 @@
+module Elastics
+  module Model
+    module Skipping
+      class << self
+        def models
+          Thread.current[:elastics_skip_models] ||= {}
+        end
+
+        def included(base)
+          base.extend self
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+      end
+
+      def skip_elastics
+        self.skip_elastics = true
+        yield
+      ensure
+        self.skip_elastics = false
+      end
+
+      module ClassMethods
+        def skip_elastics?
+          Skipping.models[self]
+        end
+
+        def skip_elastics=(val)
+          Skipping.models[self] = val
+        end
+      end
+
+      module InstanceMethods
+        attr_writer :skip_elastics
+
+        def skip_elastics?
+          @skip_elastics || self.class.skip_elastics?
+        end
+      end
+    end
+  end
+end

data/lib/elastics/model/tracking.rb

@@ -0,0 +1,29 @@
+module Elastics
+  module Model
+    class << self
+      attr_reader :list
+
+      def reset_list
+        @list = []
+      end
+
+      def track(model)
+        if !model.respond_to?(:track_elastics_model?) || model.track_elastics_model?
+          list << model
+        end
+      end
+    end
+
+    reset_list
+
+    module Tracking
+      def self.extended(base)
+        Model.track(base)
+      end
+
+      def inherited(base)
+        super.tap { Model.track(base) }
+      end
+    end
+  end
+end

data/lib/elastics/railtie.rb

@@ -11,7 +11,7 @@ module Elastics
     end
 
     config.to_prepare do
-      Elastics.reset_models
+      Model.reset_list
     end
   end
 end

data/lib/elastics/tasks/config.rb

@@ -10,7 +10,7 @@ module Elastics
       end
 
       def client
-        @client ||= Client.new config.slice(:host, :port)
+        @client ||= Client.new config.slice(:host)
       end
 
       def client=(val)

data/lib/elastics/tasks/migrations.rb

@@ -41,7 +41,7 @@ module Elastics
       def models_to_reindex(options = {})
         indices = options[:indices].try!(:map, &:to_s)
         types = options[:types].try!(:map, &:to_s)
-        models = Elastics.models.select do |model|
+        models = Model.list.select do |model|
           next if indices && !indices.include?(model.elastics_index_base)
           next if types && !types.include?(model.elastics_type_name)
           true

data/lib/elastics/version.rb

@@ -1,5 +1,5 @@
 module Elastics
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 
   def self.gem_version
     Gem::Version.new VERSION

data/lib/elastics/version_manager.rb

@@ -8,7 +8,7 @@ module Elastics
 
       def default_version=(version)
         @default_version = version
-        Elastics.models.each &:reset_elastics_index_name
+        Model.list.each &:reset_elastics_index_name
       end
 
       def use_version(version)

data/spec/lib/elastics/auto_refresh_spec.rb

@@ -21,14 +21,14 @@ describe Elastics::AutoRefresh do
       it 'invokes refresh after each request' do
         expect(client).to receive(:refresh).exactly(3).times
         client.post id: 1
-        client.put_mapping type: {fields: {}}
+        client.put_mapping type: :test, body: {fields: {}}
         client.delete id: 2
       end
 
       it 'invokes refresh after each request, not wrapped in .disable! block' do
         expect(client).to receive(:refresh).exactly(2).times
         client.post id: 1
-        described_class.disable! { client.put_mapping type: {fields: {}} }
+        described_class.disable! { client.put_mapping type: :test, body: {fields: {}} }
         client.delete id: 2
       end
     end

data/spec/lib/elastics/client/cluster_spec.rb

@@ -105,4 +105,63 @@ describe Elastics::Client do
       it { should raise_error(Elastics::Client::Cluster::NoAliveHosts) }
     end
   end
+
+  describe '#discover_cluster' do
+    let(:instance) { described_class.new(host: initial_host, discover: true).tap { |x|
+      x.singleton_class.send :attr_reader, :hosts
+    } }
+
+    let(:initial_host) { ['10.0.0.1:9200', '10.0.0.2:9200', '10.0.0.3:9200']}
+
+    let(:successful_response) do
+      {"cluster_name"=>"elasticsearch_max",
+       "nodes"=>
+        {"one"=>{"http_address"=>"inet[/10.0.0.2:9200]"},
+         "other"=>{"http_address"=>"inet[/10.0.0.1:9200]"}}}
+    end
+
+    context 'when nodes discover request fails' do
+      before do
+        expect_any_instance_of(described_class).to receive(:request) { raise Elastics::Error }
+      end
+
+      it 'fails on initialization' do
+        expect { instance }.to raise_error(Elastics::Error)
+      end
+    end
+
+    context 'when request is performed on first node' do
+      before do
+        expect_any_instance_of(described_class).to receive(:request) { successful_response }
+      end
+
+      it 'overwrites settings' do
+        expect(instance.hosts).to eq ['10.0.0.2:9200', '10.0.0.1:9200']
+      end
+    end
+
+    context 'when first is not available' do
+      before do
+        client = Object.new
+
+        expect(client).to receive(:request).
+          with(:get, "http://#{initial_host[0]}/_nodes/_all/nothing", nil, nil, Elastics::Client::HEADERS) do
+            raise Timeout::Error
+          end
+
+        expect(client).to receive(:request).
+          with(:get, "http://#{initial_host[2]}/_nodes/_all/nothing", nil, nil, Elastics::Client::HEADERS) do
+            OpenStruct.new(status: 200, body: successful_response.to_json)
+          end
+
+        allow_any_instance_of(described_class).to receive(:client) { client }
+      end
+
+      it 'keeps first node in @dead_hosts' do
+        expect(instance.hosts).to eq ['10.0.0.2:9200']
+        instance.send(:resurrect_cluster, 1.minute.from_now.to_i)
+        expect(instance.hosts).to eq ['10.0.0.2:9200', '10.0.0.1:9200']
+      end
+    end
+  end
 end

data/spec/lib/elastics/instrumentation_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Elastics::Instrumentation do
+  describe '.prettify_json' do
+    context 'when string is json' do
+      it 'parses it and yields hash into block' do
+        result = described_class.prettify_json('{"a":1}') { |x| x.keys[0] }
+        expect(result).to eq 'a'
+      end
+    end
+
+    context 'when string is multiple jsons joined with new line (bulk request)' do
+      it 'parses it into array and yields hashes into block one by one' do
+        result = described_class.prettify_json("{\"a\":1}\n{\"b\":2}") do |x|
+          x.keys[0]
+        end
+        expect(result).to eq "a\nb"
+      end
+    end
+
+    context 'when string is not json' do
+      it 'returns original string' do
+        [
+          "{\"a\":1",
+          "{\"a\":1}\n{b\":2}",
+          "{\"a\":1}\n{\"b\":2}\n{",
+          'not json'
+        ].each do |str|
+          expect(described_class.prettify_json(str) { raise }).to eq(str)
+        end
+      end
+    end
+  end
+
+  describe '.prettify_body' do
+    context 'when body_prettifier is true' do
+      before { described_class.body_prettifier = true }
+
+      it 'uses JSON.pretty_generate to prettify' do
+        expect(JSON).to receive(:pretty_generate).with('a' => 1).and_return(1)
+        expect(JSON).to receive(:pretty_generate).with('b' => 2).and_return(2)
+        expect(described_class.prettify_body("{\"a\":1}\n{\"b\":2}")).to eq "1\n2"
+      end
+    end
+  end
+
+  describe '.body_prettifier=' do
+    context 'when new value is false/nil, Proc, or valid prettifier id' do
+      it 'accepts it' do
+        [
+          :ap,
+          true,
+          ->(str) { str * 2 },
+          false,
+        ].each { |value| described_class.body_prettifier = value }
+      end
+    end
+
+    context 'when new value is invalid' do
+      it 'raises error' do
+        [
+          1,
+          :invalid,
+          Object.new,
+        ].each do |value|
+          expect { described_class.body_prettifier = value }.to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/lib/elastics/model/schema_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Elastics::Model::Schema do
+  let(:model) { Class.new.tap { |x| x.extend described_class } }
+
+  describe '#elastics_type_name' do
+    subject { model.elastics_type_name }
+
+    context 'when type was manually set' do
+      before { model.elastics_type_name = :test }
+      it { should be :test }
+    end
+
+    context 'when class name does not include modules' do
+      before { expect(model).to receive(:name) { 'Test' } }
+      it { should eq 'test' }
+    end
+
+    context 'when class name includes modules' do
+      before { expect(model).to receive(:name) { 'Module::Other::Index' } }
+      it { should eq 'index' }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'bundler/setup'
 Bundler.setup
+require 'pry'
 
 require 'elastics'
 require 'active_support/all'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elastics
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Max Melentiev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-11 00:00:00.000000000 Z
+date: 2014-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -111,7 +111,6 @@ files:
 - lib/elastics.rb
 - lib/elastics/active_record.rb
 - lib/elastics/active_record/helper_methods.rb
-- lib/elastics/active_record/instrumentation.rb
 - lib/elastics/active_record/model_schema.rb
 - lib/elastics/active_record/search_result.rb
 - lib/elastics/active_record/tasks_config.rb
@@ -120,6 +119,14 @@ files:
 - lib/elastics/client.rb
 - lib/elastics/client/bulk.rb
 - lib/elastics/client/cluster.rb
+- lib/elastics/instrumentation.rb
+- lib/elastics/instrumentation/active_support.rb
+- lib/elastics/model.rb
+- lib/elastics/model/connection.rb
+- lib/elastics/model/helper_methods.rb
+- lib/elastics/model/schema.rb
+- lib/elastics/model/skipping.rb
+- lib/elastics/model/tracking.rb
 - lib/elastics/query_helper.rb
 - lib/elastics/railtie.rb
 - lib/elastics/result.rb
@@ -136,6 +143,8 @@ files:
 - spec/lib/elastics/client/bulk_spec.rb
 - spec/lib/elastics/client/cluster_spec.rb
 - spec/lib/elastics/client_spec.rb
+- spec/lib/elastics/instrumentation_spec.rb
+- spec/lib/elastics/model/schema_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/printercu/elastics-rb
 licenses:
@@ -166,4 +175,7 @@ test_files:
 - spec/lib/elastics/client/bulk_spec.rb
 - spec/lib/elastics/client/cluster_spec.rb
 - spec/lib/elastics/client_spec.rb
+- spec/lib/elastics/instrumentation_spec.rb
+- spec/lib/elastics/model/schema_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/lib/elastics/active_record/instrumentation.rb

@@ -1,71 +0,0 @@
-module Elastics
-  module ActiveRecord
-    # To be included in `Elastics::Client`
-    module Instrumentation
-      class << self
-        def install
-          if Client.respond_to?(:prepend)
-            Client.prepend self
-          else
-            Client.send :include, Fallback
-          end
-          unless ::ActiveRecord::LogSubscriber < LogSubscriber
-            ::ActiveRecord::LogSubscriber.send :include, LogSubscriber
-          end
-        end
-      end
-
-      def http_request(*args)
-        ActiveSupport::Notifications.instrument 'request_elastics.active_record', args: args do
-          super
-        end
-      end
-
-      # old rubies support
-      module Fallback
-        extend ActiveSupport::Concern
-
-        included do
-          alias_method_chain :http_request, :instrumentation
-        end
-
-        def http_request_with_instrumentation(*args)
-          ActiveSupport::Notifications.instrument 'request_elastics.active_record', args: args do
-            http_request_without_instrumentation(*args)
-          end
-        end
-      end
-    end
-
-    module LogSubscriber
-      def self.included(base)
-        instance_methods.each { |method| base.method_added(method) }
-      end
-
-      def request_elastics(event)
-        return unless logger.debug?
-
-        payload = event.payload[:args]
-        method, path, query, body, params = payload
-        path = '/' if path.blank?
-        path << "?#{query.to_param}" if query.present?
-        model = params[:model]
-
-        name = ""
-        name << "#{model.name} " if model
-        name << "elastics (#{event.duration.round(1)}ms)"
-        request = "#{method.to_s.upcase} #{path}"
-        request << " #{body}" if body.present?
-
-        if odd?
-          name    = color(name, ActiveSupport::LogSubscriber::CYAN, true)
-          request = color(request, nil, true)
-        else
-          name = color(name, ActiveSupport::LogSubscriber::MAGENTA, true)
-        end
-
-        debug "  #{name}  #{request}"
-      end
-    end
-  end
-end