bellbro 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ab7478116c23d04ae5d103a43267dc6ad90563c
-  data.tar.gz: 259f5b67b770f5d6a4fa997eac99c3d2cb17ca92
+  metadata.gz: ad4922093fc7d4fb69b7de03b4a022637783660e
+  data.tar.gz: 42b446096f63c27560a1269f8e4d92d59bc5e6f1
 SHA512:
-  metadata.gz: 3d6c331e559941c713cacf0e4325bc5a55742b953c10d5a82494cd8cc8d6b98da78127e262e0877af93e43fae4aeeb4da6dbd112b40fe3f946ff79ac28e6523d
-  data.tar.gz: 39a37fb409cf9005de5b7ec609b7f6afb382e519eda35ec8bf1716e51c199c504c074a0764c72c36d7c9b5e90cdf5df59c6a289cd31dc6401dcff32d995434e4
+  metadata.gz: 2018607f4643fe88d4c04ea086291a35d35615f93d14c139caad7616c4e90ec0a92f3ff44dcb0d42269c2d1b140d5ead5b3782c4dfc930dacfa8ab80ac77bcb9
+  data.tar.gz: 1e6eefd6c7f3f312802f16831147a822eba4a5820debc0c9c13656322d16f19cff1a0a6d44feb271ae593e907bab226c77ca9630b655a9f9a825e0bce06aed28

data/Gemfile

@@ -1,6 +1,4 @@
 source 'https://rubygems.org'
 
-gem 'shout', path: '../shout'
-
 # Specify your gem's dependencies in bellbro.gemspec
 gemspec

data/lib/bellbro.rb

@@ -7,14 +7,16 @@ require 'digest'
 require 'sidekiq'
 require 'airbrake'
 require 'retryable'
-require 'shout'
 
 %w(
-    bellbro/hooks.rb
-    bellbro/trackable.rb
-    bellbro/sidekiq_utils.rb
-    bellbro/service.rb
-    bellbro/worker.rb
+  bellbro/settings.rb
+  bellbro/timer.rb
+  bellbro/hooks.rb
+  bellbro/ringable.rb
+  bellbro/trackable.rb
+  bellbro/sidekiq_utils.rb
+  bellbro/service.rb
+  bellbro/worker.rb
 ).each do |path|
   require File.join(File.dirname(__FILE__),path)
-end
+end

data/lib/bellbro/hooks.rb

@@ -11,7 +11,15 @@ module Bellbro
       end
 
       def abort!
-        !(@abort = true)
+        @abort = true
+      end
+
+      def timer
+        @timer ||= Bellbro::Timer.new(self.class.time_out_interval)
+      end
+
+      def timed_out?
+        timer.timed_out?
       end
     end
 
@@ -59,6 +67,14 @@ module Bellbro
         hooks.each { |hook| around_hooks.push(hook) }
       end
 
+      def time_out_in(interval)
+        @time_out_interval = interval
+      end
+
+      def time_out_interval
+        @time_out_interval
+      end
+
       # Public: Declare hooks to run before Worker invocation. The before
       # method may be called multiple times; subsequent calls append declared
       # hooks to existing before hooks.
@@ -130,7 +146,7 @@ module Bellbro
       # Returns nothing.
       def after(*hooks, &block)
         hooks << block if block
-        hooks.each { |hook| after_hooks.unshift(hook) }
+        hooks.each { |hook| after_hooks.push(hook) }
       end
 
       def always(*hooks, &block)

data/lib/bellbro/ringable.rb

@@ -0,0 +1,22 @@
+module Bellbro
+  module Ringable
+    def self.included(klass)
+      klass.extend(self)
+    end
+
+    def self.logger
+      Bellbro::Settings.logger
+    end
+
+    def error(log_line)
+      ring(log_line, type: :error)
+    end
+
+    def ring(log_line, opts={})
+      domain_insert = @domain ? "[#{@domain}]": ""
+      error_insert = (opts[:type] == :error) ? "PlatformError " : ""
+      complete_log_line = "[#{self.class}](#{Thread.current.object_id})#{domain_insert}: #{error_insert}#{log_line}"
+      Bellbro::Settings.logger.info complete_log_line
+    end
+  end
+end

data/lib/bellbro/service.rb

@@ -4,7 +4,7 @@ module Bellbro
   class Service
     include Bellbro::SidekiqUtils
     include Bellbro::Trackable
-    include Shout
+    include Bellbro::Ringable
 
     attr_reader :thread, :thread_error, :jid
 
@@ -36,23 +36,23 @@ module Bellbro
       @thread = Thread.new do
         begin
           run
-        rescue Exception => @thread_error
-          log "#{@thread_error.inspect}", type: :error
-          Airbrake.notify(@thread_error)
-          raise @thread_error
+        #rescue Exception => @thread_error
+        #  Rails.logger.info "#{@thread_error.inspect}", type: :error
+        #  Airbrake.notify(@thread_error)
+        #  raise @thread_error
         end
       end
     end
 
     def stop
       @done = true
-      log "Stopping #{self.class} service..."
+      Rails.logger.info "Stopping #{self.class} service..."
       @thread.join
-      log "#{self.class.to_s.capitalize} service stopped."
+      Rails.logger.info "#{self.class.to_s.capitalize} service stopped."
     end
 
     def run
-      log "Starting #{self.class} service."
+      Rails.logger.info "Starting #{self.class} service."
       self.class.mutex.synchronize { track }
       begin
         self.class.mutex.synchronize { start_jobs }
@@ -65,7 +65,7 @@ module Bellbro
     def start_jobs
       each_job do |job|
         jid = worker_class.perform_async(job)
-        log "Starting job #{jid} #{worker_class.name} with #{job.inspect}."
+        Rails.logger.info "Starting job #{jid} #{worker_class.name} with #{job.inspect}."
         record_incr(:jobs_started)
       end
     end

data/lib/bellbro/settings.rb

@@ -0,0 +1,24 @@
+module Bellbro
+  module Settings
+
+    class SettingsData < Struct.new(:logger)
+    end
+
+    def self.configuration
+      @configuration ||= Bellbro::Settings::SettingsData.new
+    end
+
+    def self.configure
+      yield configuration
+    end
+
+    def self.logger
+      return unless configured?
+      configuration.logger
+    end
+
+    def self.configured?
+      !!configuration
+    end
+  end
+end

data/lib/bellbro/sidekiq_utils.rb

@@ -3,112 +3,143 @@ require 'retryable'
 module Bellbro
   module SidekiqUtils
 
-    def _workers
-      Retryable.retryable(on: Redis::TimeoutError) do
-        workers_for_class("#{self.name}")
+    class Queue
+      def self.names
+        Sidekiq::Stats::Queues.new.lengths.keys
       end
-    end
 
-    def _jobs
-      Retryable.retryable(on: Redis::TimeoutError) do
-        jobs_for_class("#{self.name}")
+      def self.all
+        names.map do |name|
+          Sidekiq::Queue.new(name)
+        end
       end
-    end
 
-    def active_workers
-      _workers.map do |w|
-        {
-            :domain => worker_domain(w),
-            :jid => worker_jid(w),
-            :time => worker_time(w)
-        }
+      def self.each
+        names.each do |name|
+          yield Sidekiq::Queue.new(name)
+        end
       end
-    end
 
-    def queued_jobs
-      _jobs.map { |j| {:domain => job_domain(j), :jid => job_jid(j)} }
+      def self.clear_all
+        each do |q|
+          q.clear
+        end
+      end
     end
 
-    def workers_with_domain(domain)
-      active_workers.select { |w| w[:domain] == domain }
-    end
+    class Job
+      attr_accessor :source
 
-    def jobs_with_domain(domain)
-      queued_jobs.select { |j| j[:domain] == domain }
-    end
+      def initialize(source)
+        @source = source
+      end
 
-    def jobs_in_flight_with_domain(domain)
-      jobs_with_domain(domain) + workers_with_domain(domain)
-    end
+      def method_missing(method_name, *args, &block)
+        source.args.first.try(:[], method_name.to_s)
+      end
 
-    def workers
-      Sidekiq::Workers.new.map do |process_id, thread_id, worker|
-        worker
+      def jid
+        source.jid
       end
-    end
 
-    def workers_for_queue(q)
-      workers.select do |worker|
-        worker_queue(worker) == q
+      def self.all_for_class(klass_name)
+        Retryable.retryable(on: Redis::TimeoutError) do
+          Queue.all.map do |q|
+            q.map do |job|
+              next unless job.klass == klass_name
+              new(job)
+            end
+          end.flatten.compact
+        end
       end
     end
 
-    def workers_for_class(klass)
-      workers.select do |worker|
-        worker_class(worker) == klass
+    class Worker
+      attr_accessor :source
+
+      def initialize(source)
+        @source = source
       end
-    end
 
-    def worker_jid(worker)
-      worker["payload"]["jid"] if worker["payload"]
-    end
+      def method_missing(method_name, *args, &block)
+        args.first.try(:[],method_name.to_s)
+      end
 
-    def worker_domain(worker)
-      worker["payload"]["args"].first["domain"] if worker["payload"] && worker["payload"]["args"].try(:any?)
-    end
+      def payload
+        source["payload"] || {}
+      end
 
-    def worker_time(worker)
-      worker["run_at"]
-    end
+      def args
+        payload["args"] || []
+      end
 
-    def worker_class(worker)
-      worker["payload"]["class"] if worker["payload"]
-    end
+      def jid
+        payload["jid"]
+      end
 
-    def worker_queue(worker)
-      worker["queue"]
-    end
+      def time
+        source["run_at"]
+      end
 
-    def jobs_for_queue(q)
-      Sidekiq::Queue.new(q)
+      def klass
+        payload["class"]
+      end
+
+      def queue
+        source["queue"]
+      end
+
+      def self.all
+        Sidekiq::Workers.new.map do |process_id, thread_id, worker|
+          worker
+        end
+      end
+
+      def self.all_for_class(klass_name)
+        Retryable.retryable(on: Redis::TimeoutError) do
+          all.select do |worker|
+            worker.klass == klass_name
+          end
+        end
+      end
     end
 
-    def jobs_for_class(klass)
-      queues.map do |q|
-        jobs_for_queue(q).select { |job| job.klass == klass }
-      end.flatten
+    def workers
+      Worker.all_for_class("#{self.name}")
     end
 
-    def job_domain(job)
-      job.args.first["domain"] if job.args.any?
+    def jobs
+      Job.all_for_class("#{self.name}")
     end
 
-    def job_jid(job)
-      job.jid
+    def jobs_in_flight_with(arg)
+      jobs_with(arg) + workers_with(arg)
     end
 
-    def number_of_active_workers(q_name)
-      workers_for_queue(q_name).count
+    def jobs_with(arg)
+      key   = arg.keys.first
+      value = arg.values.first
+      jobs.select do |job|
+        value == job.send(key)
+      end
     end
 
-    def queues
-      Sidekiq::Stats::Queues.new.lengths.keys
+    def workers_with(arg)
+      key   = arg.keys.first
+      value = arg.values.first
+      workers.select do |worker|
+        value == worker.send(key)
+      end
     end
 
-    def clear_all_queues
-      queues.each do |q|
-        clear_queue(q)
+    def workers_for_queue(q)
+      workers.select do |worker|
+        worker.queue == q
       end
     end
+
+    def number_of_active_workers(q_name)
+      workers_for_queue(q_name).count
+    end
   end
-end
+end

data/lib/bellbro/timer.rb

@@ -0,0 +1,14 @@
+module Bellbro
+  class Timer
+    attr_reader :limit, :started
+
+    def initialize(limit=nil)
+      @limit ||= 1.hour
+      @started = Time.current
+    end
+
+    def timed_out?
+      Time.current - started > limit
+    end
+  end
+end

data/lib/bellbro/trackable.rb

@@ -30,13 +30,21 @@ module Bellbro
     end
 
     def status_update(force = false)
-      return unless @log_record_schema && Shout.logger
+      return unless @log_record_schema && Bellbro::Settings.logger
       return unless force || ((@count += 1) % @write_interval) == 0
-      Retryable.retryable { write_log(@record.to_json) }
+      line = Rails.env.test? ? JSON.pretty_generate(@record) : @record.to_json
+      Retryable.retryable { write_log(line) }
     end
 
     def write_log(line)
-      Shout.logger.info line
+      ring line
+    end
+
+    def record_update(attrs)
+      attrs.symbolize_keys!
+      attrs.each do |attr, value|
+        record_set(attr, value)
+      end
     end
 
     def record_set(attr, value)
@@ -45,10 +53,14 @@ module Bellbro
       @record[:data][attr] = value
     end
 
-    def record_incr(attr)
+    def record_add(attr, num)
       attr = attr.to_sym
-      validate(attr => 1)
-      @record[:data][attr] += 1
+      validate(attr => num)
+      @record[:data][attr] += num
+    end
+
+    def record_incr(attr)
+      record_add(attr, 1)
     end
 
     def stop_tracking
@@ -56,6 +68,7 @@ module Bellbro
       @record[:stopped] = Time.now.utc.iso8601
       @tracking = false
       status_update(true)
+      @record = nil
     end
 
     def tracking?
@@ -94,9 +107,9 @@ module Bellbro
     def validate(attrs)
       attrs.each do |attr, value|
         raise "Invalid attribute #{attr}" unless log_record_attributes.include?(attr)
-        raise "Invalid type for #{attr}" unless [value.class, value.class.superclass].include?(@log_record_schema[attr])
+        raise "Invalid type for #{attr}. Value #{value} is a #{value.class}, expected a #{@log_record_schema[attr]}" unless [value.class, value.class.superclass].include?(@log_record_schema[attr])
       end
     end
 
   end
-end
+end

data/lib/bellbro/version.rb

@@ -1,3 +1,3 @@
 module Bellbro
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 end

data/lib/bellbro/worker.rb

@@ -1,10 +1,10 @@
 module Bellbro
   class Worker
-    include Shout
     include Sidekiq::Worker
+    include Bellbro::Ringable
     include Bellbro::Trackable
     include Bellbro::Hooks
-    extend Bellbro::SidekiqUtils
+    extend  Bellbro::SidekiqUtils
 
     attr_reader :context
 
@@ -49,4 +49,4 @@ module Bellbro
       end
     end
   end
-end
+end

data/spec/support/shout.rb

@@ -2,6 +2,6 @@ logger = Yell.new do |l|
   l.level = [:debug, :info, :warn, :error]
 end
 
-Shout::Settings.configure do |config|
+Bellbro::Settings.configure do |config|
   config.logger = logger
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bellbro
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Jon Stokes
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-25 00:00:00.000000000 Z
+date: 2015-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -151,8 +151,11 @@ files:
 - bellbro.gemspec
 - lib/bellbro.rb
 - lib/bellbro/hooks.rb
+- lib/bellbro/ringable.rb
 - lib/bellbro/service.rb
+- lib/bellbro/settings.rb
 - lib/bellbro/sidekiq_utils.rb
+- lib/bellbro/timer.rb
 - lib/bellbro/trackable.rb
 - lib/bellbro/version.rb
 - lib/bellbro/worker.rb