rorvswild 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f8e0e177bc8b3c9645a79f0b4d39fcf27ed804f
-  data.tar.gz: 31e58a5359e4b691d80d23c23dddfaedb9a3fc76
+  metadata.gz: 97aed7e941905d99050aa05b33a2d318b49e1e74
+  data.tar.gz: ed86f80358c77f008f3e72301f99c175de6988d3
 SHA512:
-  metadata.gz: 39a57beba2498edf1ea8e1790a45991f434cfe89e925717a55c0353500d1d62a4068149510ebb24e197d82c9fa10ae9252bedea1316a0ad17694244688501382
-  data.tar.gz: bd19b326fb647010c5fba1db667804c50742b12c97ff97d58509a99b7922aed9e80ce170a78165cee50e0a9cc96a8eab45b0d046a0a03e6c964bf904d8739a50
+  metadata.gz: b2fd50627532be3543aeb2b1279bcb2e513f1a459749d53e59efd08a434bf5a863167279e446e8a574bc2d608e842f4f862cd50a8f23bbdb6eedebfa3251c192
+  data.tar.gz: c6ce663a5ba4c0e15b3da29b875a13ec607aada3d2de8855fb8ed305b6da1d0246579234405aa7e9570b1fb6f3a017f96f265eca32f6980c57929558fa45830e

data/Gemfile

@@ -13,3 +13,5 @@ gem "actionpack"
 gem "activejob"
 
 gem "delayed_job"
+gem "sidekiq"
+gem "resque"

data/lib/rorvswild/agent.rb

@@ -6,33 +6,32 @@ module RorVsWild
 
     def self.default_config
       {
-        api_url: "https://www.rorvswild.com/api",
+        api_url: "https://www.rorvswild.com/api/v1",
         ignored_exceptions: [],
       }
     end
 
     attr_reader :api_url, :api_key, :app_id, :app_root, :ignored_exceptions
 
-    attr_reader :app_root_regex, :client
+    attr_reader :app_root_regex, :client, :queue
 
     def initialize(config)
       config = self.class.default_config.merge(config)
       @ignored_exceptions = config[:ignored_exceptions]
       @app_root = config[:app_root]
-      @logger = config[:logger]
       @client = Client.new(config)
+      @queue = Queue.new(client)
       cleanup_data
 
       if defined?(Rails)
-        @logger ||= Rails.logger
         @app_root ||= Rails.root.to_s
         config = Rails.application.config
         @ignored_exceptions ||= %w[ActionController::RoutingError] + config.action_dispatch.rescue_responses.map { |(key,value)| key }
       end
 
-      @logger ||= Logger.new(STDERR)
       @app_root_regex = app_root ? /\A#{app_root}/ : nil
 
+      RorVsWild.logger.info("Start RorVsWild #{RorVsWild::VERSION} from #{app_root}")
       setup_plugins
     end
 
@@ -75,13 +74,13 @@ module RorVsWild
       end
     end
 
-    def measure_job(name, &block)
+    def measure_job(name, parameters: nil, &block)
       return block.call if data[:name] # Prevent from recursive jobs
       initialize_data(name)
       begin
         block.call
       rescue Exception => ex
-        data[:error] = exception_to_hash(ex) if !ignored_exception?(ex)
+        push_exception(ex, parameters: parameters)
         raise
       ensure
         data[:runtime] = (Time.now - data[:started_at]) * 1000
@@ -114,9 +113,11 @@ module RorVsWild
       post_error(exception_to_hash(exception, extra_details))
     end
 
-    def push_exception(exception)
+    def push_exception(exception, options = nil)
       return if ignored_exception?(exception)
       data[:error] = exception_to_hash(exception)
+      data[:error].merge!(options) if options
+      data[:error]
     end
 
     def data
@@ -152,11 +153,11 @@ module RorVsWild
     end
 
     def post_request
-      client.post_async("/requests".freeze, request: cleanup_data)
+      queue.push_request(cleanup_data)
     end
 
     def post_job
-      client.post_async("/jobs".freeze, job: cleanup_data)
+      queue.push_job(cleanup_data)
     end
 
     def post_error(hash)

data/lib/rorvswild/plugin/active_job.rb

@@ -9,7 +9,7 @@ module RorVsWild
       end
 
       def self.around_perform(job, block)
-        RorVsWild.measure_block(job.class.name, &block)
+        RorVsWild.agent.measure_job(job.class.name, parameters: job.arguments, &block)
       end
     end
   end

data/lib/rorvswild/plugin/delayed_job.rb

@@ -9,7 +9,7 @@ module RorVsWild
       end
 
       def self.around_perform(job, &block)
-        RorVsWild.measure_block(job.name) { block.call(job) }
+        RorVsWild.agent.measure_job(job.name, parameters: job.payload_object) { block.call(job) }
       end
     end
   end

data/lib/rorvswild/plugin/resque.rb

@@ -6,7 +6,7 @@ module RorVsWild
       end
 
       def around_perform_rorvswild(*args, &block)
-        RorVsWild.measure_block(to_s, &block)
+        RorVsWild.agent.measure_job(to_s, parameters: args, &block)
       end
     end
   end

data/lib/rorvswild/plugin/sidekiq.rb

@@ -11,7 +11,8 @@ module RorVsWild
 
       def call(worker, item, queue, &block)
         # Wrapped contains the real class name of the ActiveJob wrapper
-        RorVsWild.measure_block(item["wrapped".freeze] || item["class".freeze], &block)
+        name = item["wrapped".freeze] || item["class".freeze]
+        RorVsWild.agent.measure_job(name, parameters: item["args".freeze], &block)
       end
     end
   end

data/lib/rorvswild/queue.rb

@@ -0,0 +1,71 @@
+module RorVsWild
+  class Queue
+    SLEEP_TIME = 10
+    FLUSH_TRESHOLD = 10
+
+    attr_reader :mutex, :thread, :client
+    attr_reader :requests, :jobs
+
+    def initialize(client)
+      @jobs = []
+      @requests = []
+      @client = client
+      @mutex = Mutex.new
+    end
+
+    def push_job(data)
+      push_to(jobs, data)
+    end
+
+    def push_request(data)
+      push_to(requests, data)
+    end
+
+    def push_to(array, data)
+      mutex.synchronize do
+        wakeup_thread if array.push(data).size >= FLUSH_TRESHOLD
+      end
+    end
+
+    def pull_jobs
+      mutex.synchronize do
+        if jobs.size > 0
+          result = jobs
+          @jobs = []
+          return result
+        end
+      end
+    end
+
+    def pull_requests
+      mutex.synchronize do
+        if requests.size > 0
+          result = requests
+          @requests = []
+          return result
+        end
+      end
+    end
+
+    def flush_indefinetely
+      sleep(SLEEP_TIME) and flush while true
+    rescue Exception => ex
+      RorVsWild.logger.error(ex)
+      raise
+    end
+
+    def flush
+      RorVsWild.logger.info("flush")
+      data = pull_jobs and client.post("/jobs", jobs: data)
+      data = pull_requests and client.post("/requests", requests: data)
+    end
+
+    def start_thread
+      @thread = Thread.new { flush_indefinetely }
+    end
+
+    def wakeup_thread
+      (thread && thread.alive?) ? thread.wakeup : start_thread
+    end
+  end
+end

data/lib/rorvswild/version.rb

@@ -1,3 +1,3 @@
 module RorVsWild
-  VERSION = "1.0.1".freeze
+  VERSION = "1.1.0".freeze
 end

data/lib/rorvswild.rb

@@ -3,17 +3,26 @@ require "rorvswild/location"
 require "rorvswild/section"
 require "rorvswild/client"
 require "rorvswild/plugins"
+require "rorvswild/queue"
 require "rorvswild/agent"
 
 module RorVsWild
   def self.start(config)
+    @logger = initialize_logger(config[:logger])
     @agent = Agent.new(config)
+  rescue Exception => ex
+    logger.error(ex)
+    raise
   end
 
   def self.agent
     @agent
   end
 
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
   def self.measure_code(code)
     agent ? agent.measure_code(code) : eval(code)
   end
@@ -29,6 +38,14 @@ module RorVsWild
   def self.record_error(exception, extra_details = nil)
     agent.record_error(exception, extra_details) if agent
   end
+
+  def self.initialize_logger(destination)
+    if destination
+      Logger.new(destination)
+    elsif defined?(Rails)
+      Logger.new(Rails.root + "log/rorvswild.log")
+    end
+  end
 end
 
 if defined?(Rails)

data/test/measure_nested_sections_test.rb

@@ -2,7 +2,6 @@ require File.expand_path("#{File.dirname(__FILE__)}/helper")
 
 class RorVsWild::MeasureNestedSectionsTest < Minitest::Test
   include RorVsWildAgentHelper
-  include TopTests
 
   def test_measure_section
     result = agent.measure_block("root") do

data/test/plugin/active_job_test.rb

@@ -8,14 +8,25 @@ class RorVsWild::Plugin::ActiveJobTest < Minitest::Test
   class SampleJob < ::ActiveJob::Base
     queue_as :default
 
-    def perform
+    def perform(arg)
+      raise "Exception" unless arg
     end
   end
 
   def test_callback
     ActiveJob::Base.logger = Logger.new("/dev/null")
     agent.expects(:post_job)
-    SampleJob.perform_now
+    SampleJob.perform_now(1)
+    assert_equal("RorVsWild::Plugin::ActiveJobTest::SampleJob", agent.data[:name])
+  end
+
+  def test_callback_on_exception
+    ActiveJob::Base.logger = Logger.new("/dev/null")
+    agent.expects(:post_job)
+    SampleJob.perform_now(false)
+  rescue
+  ensure
+    assert_equal([false], agent.data[:error][:parameters])
   end
 end
 

data/test/plugin/delayed_job_test.rb

@@ -6,30 +6,39 @@ class RorVsWild::Plugin::DelayedJobTest < Minitest::Test
   include RorVsWildAgentHelper
 
   class SampleJob
+    def initialize(arg)
+      @arg = arg
+    end
+
     def perform
+      raise "Exception" unless @arg
     end
   end
 
+  Delayed::Worker.delay_jobs = false
+
   class SampleBackend
     include Delayed::Backend::Base
 
-    attr_accessor :id,  :attempts
+    attr_accessor :handler
 
     def initialize(options)
-    end
-
-    def payload_object
-      SampleJob.new
-    end
-
-    def destroy
+      @payload_object = options[:payload_object]
     end
   end
 
   def test_callback
     agent.expects(:post_job)
-    Delayed::Worker.delay_jobs = false
-    SampleBackend.enqueue(SampleJob.new)
+    SampleBackend.enqueue(SampleJob.new(true))
+    assert_equal("RorVsWild::Plugin::DelayedJobTest::SampleJob", agent.data[:name])
+  end
+
+  def test_callback_on_exception
+    agent.expects(:post_job)
+    SampleBackend.enqueue(job = SampleJob.new(false))
+  rescue
+  ensure
+    assert_equal(job, agent.data[:error][:parameters])
   end
 end
 

data/test/plugin/resque_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "resque"
+
+class RorVsWild::Plugin::ResqueTest < Minitest::Test
+  include RorVsWildAgentHelper
+
+  Resque.inline = true
+
+  class SampleJob < Resque::Job
+    @queue = :default
+
+    def self.perform(arg)
+      raise "Exception" unless arg
+    end
+  end
+
+  def test_callback
+    agent.expects(:post_job)
+    Resque.enqueue(SampleJob, true)
+    assert_equal("RorVsWild::Plugin::ResqueTest::SampleJob", agent.data[:name])
+  end
+
+  def test_callback_on_exception
+    agent.expects(:post_job)
+    Resque.enqueue(SampleJob, false)
+  rescue
+  ensure
+    assert_equal([false], agent.data[:error][:parameters])
+  end
+end
+

data/test/plugin/sidekiq_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+require "sidekiq"
+require "sidekiq/testing"
+
+class RorVsWild::Plugin::SidekiqTest < Minitest::Test
+  include RorVsWildAgentHelper
+
+  Sidekiq::Testing.server_middleware do |chain|
+    chain.add(RorVsWild::Plugin::Sidekiq)
+  end
+
+  class SampleJob
+    include ::Sidekiq::Worker
+
+    # SampleSidekiqJob.perform_async(1)
+    def perform(arg)
+      raise "Exception" unless arg
+    end
+  end
+
+  def test_callback
+    agent.expects(:post_job)
+    Sidekiq::Testing.inline! { SampleJob.perform_async(1) }
+    assert_equal("RorVsWild::Plugin::SidekiqTest::SampleJob", agent.data[:name])
+  end
+
+  def test_callback_on_exception
+    agent.expects(:post_job)
+    Sidekiq::Testing.inline! { SampleJob.perform_async(false) }
+  rescue
+  ensure
+    assert_equal([false], agent.data[:error][:parameters])
+  end
+end
+

data/test/queue_test.rb

@@ -0,0 +1,52 @@
+require File.expand_path("#{File.dirname(__FILE__)}/helper")
+
+class QueueTest < Minitest::Test
+  def test_push_job
+    queue.thread.expects(:wakeup)
+    10.times { queue.push_job(1) }
+    assert_equal(10, queue.jobs.size)
+  end
+
+  def test_push_request
+    queue.thread.expects(:wakeup)
+    10.times { queue.push_request(1) }
+    assert_equal(10, queue.requests.size)
+  end
+
+  def test_pull_jobs
+    queue.push_job(1)
+    assert_equal([1], queue.pull_jobs)
+    refute(queue.pull_jobs)
+  end
+
+  def test_pull_requests
+    queue.push_request(1)
+    assert_equal([1], queue.pull_requests)
+    refute(queue.pull_requests)
+  end
+
+  def test_flush_when_jobs_are_present
+    queue.client.expects(:post)
+    queue.push_job(1)
+    queue.flush
+  end
+
+  def test_flush_when_requests_are_present
+    queue.client.expects(:post)
+    queue.push_request(1)
+    queue.flush
+  end
+
+  def test_flush_when_empty
+    queue.client.expects(:post).never
+    queue.flush
+  end
+
+  def queue
+    @queue ||= RorVsWild::Queue.new(client)
+  end
+
+  def client
+    @client ||= RorVsWild::Client.new({})
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rorvswild
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Alexis Bernard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-14 00:00:00.000000000 Z
+date: 2017-08-02 00:00:00.000000000 Z
 dependencies: []
 description: Performances and quality insights for rails developers.
 email:
@@ -42,6 +42,7 @@ files:
 - lib/rorvswild/plugin/resque.rb
 - lib/rorvswild/plugin/sidekiq.rb
 - lib/rorvswild/plugins.rb
+- lib/rorvswild/queue.rb
 - lib/rorvswild/rails_loader.rb
 - lib/rorvswild/section.rb
 - lib/rorvswild/version.rb
@@ -57,6 +58,9 @@ files:
 - test/plugin/mongo_test.rb
 - test/plugin/net_http_test.rb
 - test/plugin/redis_test.rb
+- test/plugin/resque_test.rb
+- test/plugin/sidekiq_test.rb
+- test/queue_test.rb
 - test/rorvswild_test.rb
 - test/run.rb
 - test/section_test.rb
@@ -96,6 +100,9 @@ test_files:
 - test/plugin/mongo_test.rb
 - test/plugin/net_http_test.rb
 - test/plugin/redis_test.rb
+- test/plugin/resque_test.rb
+- test/plugin/sidekiq_test.rb
+- test/queue_test.rb
 - test/rorvswild_test.rb
 - test/run.rb
 - test/section_test.rb