harness 0.9.1 → 1.0.0

data/harness.gemspec

@@ -4,7 +4,7 @@ require File.expand_path('../lib/harness/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["ahawkins"]
   gem.email         = ["adam@hawkins.io"]
-  gem.description   = %q{Log ActiveSupport::Notifications to various services like Librato or StatsD}
+  gem.description   = %q{Collect high level application performance metrics and forward them for analysis}
   gem.summary       = %q{}
   gem.homepage      = "https://github.com/ahawkins/harness"
 
@@ -16,17 +16,8 @@ Gem::Specification.new do |gem|
   gem.version       = Harness::VERSION
 
   gem.add_dependency "activesupport", ">= 3"
-  gem.add_dependency "redis"
-  gem.add_dependency "redis-namespace"
-  gem.add_dependency "multi_json"
+  gem.add_dependency "statsd-ruby"
 
   gem.add_development_dependency "simplecov"
-  gem.add_development_dependency "webmock"
-  gem.add_development_dependency "resque"
-  gem.add_development_dependency "sidekiq"
-  gem.add_development_dependency "delayed_job_active_record"
-  gem.add_development_dependency "active_model_serializers"
-  gem.add_development_dependency "rails", ">= 3"
-  gem.add_development_dependency "sqlite3"
-  gem.add_development_dependency "statsd-instrument"
+  gem.add_development_dependency "rake"
 end

data/lib/harness.rb

@@ -1,52 +1,57 @@
 require "harness/version"
 
-require 'multi_json'
-
-require 'redis'
-require 'redis/namespace'
-
+require 'statsd'
 require 'active_support/notifications'
-require 'active_support/core_ext/string'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/numeric'
-require 'active_support/core_ext/integer'
-
-require 'active_support/ordered_options'
 
 module Harness
-  class LoggingError < RuntimeError ; end
-  class NoCounter < RuntimeError ; end
-
   class Config
-    attr_reader :adapter, :queue
-    attr_accessor :namespace, :source
-    attr_reader :instrument
+    attr_accessor :collector, :queue
+  end
 
-    def initialize
-      @instrument = ActiveSupport::OrderedOptions.new
+  Measurement = Struct.new(:name, :value, :rate) do
+    def self.from_event(event)
+      payload = event.payload
+      value = payload.fetch name.split('::').last.downcase.to_sym
+
+      case value
+      when true
+        new event.name
+      when Fixnum
+        new event.name, value
+      when String
+        new value
+      when Hash
+        new(value[:name] || event.name, value[:value], value[:rate])
+      end
     end
 
-    def adapter=(val)
-      if val.is_a? Symbol
-        @adapter = "Harness::#{val.to_s.camelize}Adapter".constantize.new
-      else
-        @adapter = val
-      end
+    def sample_rate
+      rate.nil? ? 1 : rate
     end
+  end
 
-    def queue=(val)
-      if val.is_a? Symbol
-        @queue = "Harness::#{val.to_s.camelize}Queue".constantize.new
-      else
-        @queue = val
-      end
+  class Timer < Measurement
+    def self.from_event(event)
+      timer = super
+      timer.value = event.duration
+      timer
+    end
+
+    def ms
+      value
     end
 
-    def method_missing(name, *args, &block)
-      begin
-        "Harness::#{name.to_s.camelize}Adapter".constantize.config
-      rescue NameError
-        super
+    def log
+      Harness.timing name, ms, sample_rate
+    end
+  end
+
+  class Counter < Measurement
+    def log
+      if value.nil?
+        Harness.increment name, sample_rate
+      else
+        Harness.count name, value, sample_rate
       end
     end
   end
@@ -55,53 +60,49 @@ module Harness
     @config ||= Config.new
   end
 
-  def self.log(measurement)
-    config.queue.push measurement
+  def self.increment(*args)
+    queue.push [:increment, args]
   end
 
-  def self.logger
-    @logger
+  def self.decrement(*args)
+    queue.push [:decrement, args]
   end
 
-  def self.logger=(logger)
-    @logger = logger
+  def self.timing(*args)
+    queue.push [:timing, args]
   end
 
-  def self.redis=(redis)
-    @redis = redis
+  def self.count(*args)
+    queue.push [:count, args]
   end
 
-  def self.redis
-    @redis
+  def self.time(stat, sample_rate = 1)
+    start = Time.now
+    result = yield
+    timing(stat, ((Time.now - start) * 1000).round, sample_rate)
+    result
   end
 
-  def self.reset_counters!
-    counters.each do |counter|
-      redis.set counter, 0
-    end
+  def self.gauge(*args)
+    queue.push [:gauge, args]
   end
 
-  def self.counters
-    redis.keys "counters/*"
+  def self.queue
+    config.queue
   end
-end
-
-require 'harness/measurement'
-require 'harness/counter'
-require 'harness/gauge'
 
-require 'harness/instrumentation'
-
-require 'harness/job'
-
-require 'harness/queues/synchronous_queue'
+  def self.collector
+    config.collector
+  end
+end
 
-require 'harness/adapters/librato_adapter'
-require 'harness/adapters/memory_adapter'
-require 'harness/adapters/null_adapter'
+require 'harness/sync_queue'
+require 'harness/async_queue'
 
-require 'harness/railtie' if defined?(Rails)
+require 'harness/null_collector'
+require 'harness/fake_collector'
 
-require 'logger'
+require 'harness/instrumentation'
+require 'harness/subscription'
 
-Harness.logger = Logger.new $stdout
+Harness.config.queue = Harness::AsyncQueue.new

data/lib/harness/async_queue.rb

@@ -0,0 +1,29 @@
+require 'thread'
+
+module Harness
+  class AsyncQueue
+    attr_reader :consumer, :queue
+
+    def initialize
+      @queue = Queue.new
+      @consumer = Thread.new do
+        loop do
+          msg = queue.pop
+
+          method_name = msg.first
+          args = msg.last
+
+          collector.__send__ method_name, *args
+        end
+      end
+    end
+
+    def push(msg)
+      queue.push msg
+    end
+
+    def collector
+      Harness.collector
+    end
+  end
+end

data/lib/harness/fake_collector.rb

@@ -0,0 +1,40 @@
+module Harness
+  class FakeCollector
+    Increment = Struct.new(:name, :amount, :rate)
+    Decrement = Struct.new(:name, :amount, :rate)
+    Gauge = Struct.new(:name, :value, :rate)
+
+    attr_reader :gauges, :counters, :timers, :increments, :decrements
+
+    def initialize
+      @gauges, @counters, @timers, @increments, @decrements = [], [], [], [], []
+    end
+
+    def timing(*args)
+      timers << Harness::Timer.new(*args)
+    end
+
+    def time(stat, sample_rate = 1)
+      start = Time.now
+      result = yield
+      timing(stat, ((Time.now - start) * 1000).round, sample_rate)
+      result
+    end
+
+    def increment(*args)
+      increments << Increment.new(*args)
+    end
+
+    def decrement(*args)
+      decrements << Decrement.new(*args)
+    end
+
+    def count(*args)
+      counters << Harness::Counter.new(*args)
+    end
+
+    def gauge(*args)
+      gauges << Gauge.new(*args)
+    end
+  end
+end

data/lib/harness/instrumentation.rb

@@ -1,8 +1,23 @@
-ActiveSupport::Notifications.subscribe %r{.+} do |*args|
-  event = ActiveSupport::Notifications::Event.new(*args)
-    
-  unless event.payload[:exception]
-    Harness::Gauge.from_event(event).log if event.payload[:gauge]
-    Harness::Counter.from_event(event).log if event.payload[:counter]
+module Harness
+  module Instrumentation
+    def timing(*args)
+      Harness.timing *args
+    end
+
+    def time(*args, &block)
+      Harness.time *args, &block
+    end
+
+    def gauge(*args)
+      Harness.gauge *args
+    end
+
+    def increment(*args)
+      Harness.increment *args
+    end
+
+    def decrement(*args)
+      Harness.decrement *args
+    end
   end
 end

data/lib/harness/null_collector.rb

@@ -0,0 +1,23 @@
+module Harness
+  class NullCollector
+    def increment(*args)
+
+    end
+
+    def count(*args)
+
+    end
+
+    def time(*args, &block)
+      yield block
+    end
+
+    def timing(*args)
+
+    end
+
+    def gauge(*args)
+
+    end
+  end
+end

data/lib/harness/subscription.rb

@@ -0,0 +1,7 @@
+ActiveSupport::Notifications.subscribe do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  next if event.payload[:exception]
+
+  Harness::Timer.from_event(event).log if event.payload[:timer]
+  Harness::Counter.from_event(event).log if event.payload[:counter]
+end

data/lib/harness/sync_queue.rb

@@ -0,0 +1,14 @@
+module Harness
+  class SyncQueue
+    def push(msg)
+      method_name = msg.first
+      args = msg.last
+
+      collector.__send__ method_name, *args
+    end
+
+    def collector
+      Harness.collector
+    end
+  end
+end

data/lib/harness/version.rb

@@ -1,3 +1,3 @@
 module Harness
-  VERSION = "0.9.1"
+  VERSION = "1.0.0"
 end

data/test/acceptance_test.rb

@@ -0,0 +1,20 @@
+require_relative 'test_helper'
+
+class AcceptanceTest < MiniTest::Unit::TestCase
+  def test_works_with_actual_statsd
+    Harness.config.collector = Statsd.new
+    Harness.config.queue = Harness::SyncQueue.new
+
+    Harness.increment 'foo', 0.6
+    Harness.decrement 'foo', 0.5
+    Harness.count 'foo', 5, 0.5
+
+    Harness.gauge 'foo', 0.5, 0.1
+
+    Harness.timing 'foo', 0.5, 0.1
+
+    Harness.time 'foo', 1 do
+      true
+    end
+  end
+end

data/test/active_support_notifications_test.rb

@@ -0,0 +1,93 @@
+require_relative 'test_helper'
+
+class ActiveSupportNotificationsTestCase < MiniTest::Unit::TestCase
+  def test_timers_are_logged
+    instrument 'test', timer: true
+
+    refute_empty timers
+    timer = timers.first
+    assert_equal 'test', timer.name
+    assert_kind_of Float, timer.ms
+  end
+
+  def test_timer_name_can_be_customized
+    instrument 'test', timer: 'foo'
+
+    refute_empty timers
+    timer = timers.first
+    assert_equal 'foo', timer.name
+  end
+
+  def test_timer_rate_can_be_customized
+    instrument 'test', timer: { rate: 0.5, name: 'foo', value: 5 }
+
+    refute_empty timers
+    timer = timers.first
+    assert_equal 0.5, timer.rate
+    assert_equal 'foo', timer.name
+  end
+
+  def test_passed_value_does_not_override_blocks
+    instrument 'test', timer: { rate: 0.5, name: 'foo', value: 5 }
+
+    refute_empty timers
+    timer = timers.first
+    refute_equal 5, timer.value
+  end
+
+  def test_does_not_log_timers_on_exception
+    begin
+      instrument 'test', timer: true do
+        raise
+      end
+    rescue
+    end
+
+    assert_empty timers
+  end
+
+  def test_counters_with_no_value_are_treated_as_increments
+    instrument 'test', counter: true
+
+    refute_empty increments
+    counter = increments.first
+    assert_equal 'test', counter.name
+  end
+
+  def test_counters_can_have_explicit_values
+    instrument 'test', counter: 5
+
+    refute_empty counters
+    counter = counters.first
+    assert_equal 'test', counter.name
+  end
+
+  def test_counter_name_can_be_customized
+    instrument 'test', counter: 'foo'
+
+    refute_empty increments
+    counter = increments.first
+    assert_equal 'foo', counter.name
+  end
+
+  def test_counter_rate_can_be_customized
+    instrument 'test', counter: { rate: 0.5, name: 'foo', value: 5 }
+
+    refute_empty counters
+    counter = counters.first
+    assert_equal 0.5, counter.rate
+    assert_equal 'foo', counter.name
+    assert_equal 5, counter.value
+  end
+
+  def test_does_not_log_counters_on_exceptions
+    begin
+      instrument 'test', counter: true do
+        raise
+      end
+    rescue
+    end
+
+    assert_empty counters
+  end
+end