hallmonitor 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1079939216599f5d80202ba8bc96224365fbef78
-  data.tar.gz: 4fea628bc6f7faff08a44e71353ed8a4b6cdef17
+  metadata.gz: c7417d6498baf7f73a8d717ed8497503ab3ffc22
+  data.tar.gz: 3e5887d9e7bf1220f1fc12e02479cff211c9cbed
 SHA512:
-  metadata.gz: 85a0f7f5276194396bc7b6c89d095661f676c4a511b61145b88a9129fa19fbfac3ebcfcfe447691555c43828a0410fc1933968f5110c60bfb6390bfcc786f567
-  data.tar.gz: dc97db0cf695876cc8aa50bb578bac2f2be58218c5fa7d349dc9eea46fbfed8dad7f3a659f5c2b9a06e50d69939359df9d63d97a83236e1e1e022b94dbcedf49
+  metadata.gz: 13952cb19e2809073797e2a2c99b2b540b0d192090442de5b406ca424075b0be32bd4cf4c257897803e636af0cb5ced054f840b64f297d716593010d3a97255c
+  data.tar.gz: a23cf1b369e6713251b0f34c2920862b0bf18697f22536a97da80bb73205a48df64da4f7960fa74916caa4a36bcb2af4563c7174e33027f4844ba3e1ec340e0d

data/README.md

@@ -2,7 +2,8 @@
 
 Hallmonitor is a simple event monitoring framework for Ruby.  It allows programs to define and emit events. These events can then be sent on to various back ends to be counted, monitored, etc.
 
-Hallmonitor includes support for publishing events to a Statsd instance if the `statsd-ruby` gem is installed.  See https://github.com/reinh/statsd for details
+Hallmonitor includes support for publishing events to a Statsd instance if the `statsd-ruby` gem is installed.  See https://github.com/reinh/statsd for details.
+It also includes support for outputting events to InfluxDB if the 'influxdb' gem is installed.
 
 ## Setup
 Before you can use Hallmonitor you have to do a tiny bit of configuration in the form of adding outputters.

data/lib/hallmonitor/dispatcher.rb

@@ -31,7 +31,7 @@ module Hallmonitor
         begin
           o.process(event)
         rescue
-          raise unless Hallmonitor.config.trap_outputter_exceptions
+          raise unless Hallmonitor.config && Hallmonitor.config.trap_outputter_exceptions
         end
       end
       nil

data/lib/hallmonitor/event.rb

@@ -9,8 +9,10 @@ module Hallmonitor
 
     # Builds a new event
     # @param name [String] the name of this event
-    # @param count [Number] the count of this even, defaults to 1
-    def initialize(name, count=1, tags: {})
+    # @param count [Number,Hash] the count of this even, defaults to 1.  Can
+    #   also be a hash of named value pairs
+    # @param tags [Hash<Symbol,String>] Hash of tags to values for this event
+    def initialize(name, count: 1, tags: {})
       @name = name
       @time = Time.now
       @count = count

data/lib/hallmonitor/gauge_event.rb

@@ -6,8 +6,8 @@ module Hallmonitor
   class GaugeEvent < Event
     # @param name [String] Name of this guage
     # @param value [Number] The current value of this guage
-    def initialize(name, value)
-      super(name, value)
+    def initialize(name, value: nil, tags: {})
+      super(name, count: value, tags: tags)
     end
 
     # The value of this guage

data/lib/hallmonitor/outputter.rb

@@ -7,7 +7,7 @@ module Hallmonitor
     # @param name [Object] Probably a string or symbol, the name of this
     # outputter
     def initialize(name)
-      raise(ArgumentError, "Outputter expects a name") if name.nil?
+      fail(ArgumentError, 'Outputter expects a name') if name.nil?
       @name = name
     end
 

data/lib/hallmonitor/outputters/influxdb.rb

@@ -5,50 +5,98 @@ end
 
 module Hallmonitor
   module Outputters
-    # An outputter for StatsD
-    class InfluxdbOutputter < Outputter
-      # Builds a new InfluxdbOutputter
+    # An outputter for InfluxDB
+    class Influxdb < Outputter
+      # Builds a new Influxdb outputter
       # @param influxdb_client [InfluxDB::Client] client instance to use
       # @param tags [Hash] Set of default tags applied to all events output to
       #   InfluxDB, will be overridden by tags set by events if they conflict
-      # @raise if Statsd is undefined (Gem not present)
-      def initialize(influxdb_client, tags)
-        raise "In order to use InfluxdbOutputter, influxdb gem must be installed" unless defined?(InfluxDB)
-        super("influxdb")
-        @tags = tags
-        @client = influxdb_client
+      # @param transformer [#transform(String)] An object that responds
+      #   to #transform(String).  If supplied it will be passed each event name
+      #   and should return a hash with keys :name and :tags.  This is to allow
+      #   for transition from a statsd/graphite style event naming convention to
+      #   an InfluxDb style name+tags convention.  Any tags returned by the
+      #   transformer will defer to tags specified in the event itself, in
+      #   other words if the event has tags already they will take precedence
+      #   over tags built by the transformer
+      # @raise if influxdb_client does not respond to :write_point
+      #   (InfluxDB::Client contract)
+      def initialize(influxdb_client, tags = {}, transformer = nil)
+        unless influxdb_client.respond_to?(:write_point)
+          fail 'Supplied InfluxDB Client was not as expected'
+        end
+
+        if transformer && !transformer.respond_to?(:transform)
+          fail 'Supplied transformer does not respond to :transform'
+        end
+
+        super('influxdb')
+        @tags = {}.merge(tags)
+        @client = influxdb_client || fail('Must supply an InfluxDb client')
+        @transformer = transformer
       end
 
-      # Sends events to statsd instance
+      # Sends events to InfluxDB instance
+      # @param evvent []
       def process(event)
-        tags = @tags.merge(event.tags)
-
-        data = {}
-
-        if(event.respond_to?(:duration))
-          tags = {type: 'timer'}.merge(tags)
-          data = {
-            values: {value: event.duration},
-            tags: tags
-          }
-          @client.write_point(event.name, data)
-        elsif(event.respond_to?(:value))
-          tags = {type: 'guage'}.merge(tags)
-          data = {
-            values: {value: event.value},
-            tags: tags
-          }
+        data =
+          if event.is_a?(Hallmonitor::TimedEvent)
+            build_timer_data(event)
+          elsif event.is_a?(Hallmonitor::GaugeEvent)
+            build_gauge_data(event)
+          else
+            build_counter_data(event)
+          end
+        transform_and_write(event, data)
+      end
+
+      private
+
+      def transform_and_write(event, data)
+        to_write = transform(event, data)
+        @client.write_point(to_write[:name], to_write[:data])
+      end
+
+      # If @transformer exists, use it to transform the event name
+      # and possibly build tags from it.
+      # @param event [Event] The event we're working with
+      # @param data [Hash] Hash of data we're building for InfluxDB,
+      #   Will be modified directly if the transformer is specified.
+      # @see {#build_data} for information on the structure of `data`
+      def transform(event, data)
+        if @transformer
+          t = @transformer.transform(event.name)
+          data[:tags] = (t[:tags] || {}).merge(data[:tags])
+          { name: t[:name], data: data }
         else
-          tags = {type: 'count'}.merge(tags)
-          data = {
-            values: {value: event.count},
-            tags: tags
-          }
+          { name: event.name, data: data }
         end
+      end
+
+      def build_data(event, type, value)
+        data = {
+          tags: @tags.merge(event.tags.merge(type: type))
+        }
 
-        @client.write_point(event.name, data)
+        if value.is_a?(Hash)
+          data[:values] = value
+        else
+          data[:values] = { value: value }
+        end
+        data
       end
 
+      def build_timer_data(event)
+        build_data(event, 'timer', event.duration)
+      end
+
+      def build_gauge_data(event)
+        build_data(event, 'gauge', event.value)
+      end
+
+      def build_counter_data(event)
+        build_data(event, 'count', event.count)
+      end
     end
   end
 end

data/lib/hallmonitor/outputters/iooutputter.rb

@@ -4,7 +4,6 @@ module Hallmonitor
   module Outputters
     # Simple outputter that just prints to an output stream
     class IOOutputter < Outputter
-
       # Builds a new IOOutputter
       # @param name [String] Name for this outputter
       # @param out [IO] Output to write to
@@ -16,15 +15,14 @@ module Hallmonitor
       # Sends an event to the configured output
       # on IOError the output will be closed
       def process(event)
-        begin
-          @out.print "EVENT: #{event.to_json}\n"
-          @out.flush
-        rescue IOError => e
-          close
-        end
+        @out.print "EVENT: #{event.to_json}\n"
+        @out.flush
+      rescue IOError
+        close
       end
 
       private
+
       def close
         @out.close unless @out.nil?
       end

data/lib/hallmonitor/outputters/new_relic.rb

@@ -5,25 +5,58 @@ module Hallmonitor
       # Initializes a new instance
       # @raise String if {NewRelic::Agent} isn't defined (Library isn't loaded)
       # @param prefix [String] String to prefix all metrics with
-      def initialize(prefix='')
-        raise "In order to use NewRelic, new_relic gem must be installed" unless defined?(::NewRelic::Agent)
+      def initialize(prefix = '')
+        unless defined?(::NewRelic::Agent)
+          fail 'In order to use NewRelic, new_relic gem must be installed'
+        end
         super(prefix)
       end
 
       def process(event)
-        if(event.respond_to?(:duration))
-          ::NewRelic::Agent.record_metric(new_relic_name(event), event.duration)
-        elsif(event.respond_to?(:value))
-          ::NewRelic::Agent.record_metric(new_relic_name(event), event.value)
+        if event.is_a?(Hallmonitor::TimedEvent)
+          process_timed_event(event)
+        elsif event.is_a?(Hallmonitor::GaugeEvent)
+          process_gauge_event(event)
         else
-          ::NewRelic::Agent.increment_metric(new_relic_name(event), event.count)
+          process_event(event)
         end
       end
 
       private
+
+      def process_timed_event(event)
+        if event.duration.is_a?(Hash)
+          event.duration.each do |name, value|
+            ::NewRelic::Agent.record_metric(new_relic_name("#{event.name}.#{name}"), value)
+          end
+        else
+          ::NewRelic::Agent.record_metric(new_relic_name(event.name), event.duration)
+        end
+      end
+
+      def process_gauge_event(event)
+        if event.value.is_a?(Hash)
+          event.value.each do |name, value|
+            ::NewRelic::Agent.record_metric(new_relic_name("#{event.name}.#{name}"), value)
+          end
+        else
+          ::NewRelic::Agent.record_metric(new_relic_name(event.name), event.value)
+        end
+      end
+
+      def process_event(event)
+        if event.count.is_a?(Hash)
+          event.count.each do |name, value|
+            ::NewRelic::Agent.increment_metric(new_relic_name("#{event.name}.#{name}"), value)
+          end
+        else
+          ::NewRelic::Agent.increment_metric(new_relic_name(event.name), event.count)
+        end
+      end
+
       # Formats the event name into the naming scheme that NewRelic expects
-      def new_relic_name(event)
-        "Custom/#{event.name.gsub('.','/')}"
+      def new_relic_name(name)
+        "Custom/#{name.tr('.', '/')}"
       end
     end
   end

data/lib/hallmonitor/outputters/statsd_outputter.rb

@@ -12,24 +12,77 @@ module Hallmonitor
       #   the prefix will be applied to all event names before sending to statsd
       # @param host [String] Statsd Host, defaults to 'localhost'
       # @param port [Number] Statsd Port, defaults to 8125
+      # @param transformer [#transform(event)] An object that responds
+      #   to #transform(Event).  If supplied it will be passed each event
+      #   and should return an event name.  This is to allow for flattening any
+      #   tags present in the event into a flattened name structure.
       # @raise if Statsd is undefined (Gem not present)
-      def initialize(prefix, host="localhost", port=8125)
-        raise "In order to use StatsdOutputter, statsd gem must be installed" unless defined?(Statsd)
+      def initialize(prefix, host = 'localhost', port = 8125, transformer = nil)
+        unless defined?(Statsd)
+          fail 'In order to use StatsdOutputter, statsd gem must be installed'
+        end
+
+        if transformer && !transformer.respond_to?(:transform)
+          fail 'Supplied transformer does not respond to :transform'
+        end
+
         super(prefix)
-        @statsd = Statsd.new(host).tap{|sd| sd.namespace = name}
+        @statsd = Statsd.new(host).tap { |sd| sd.namespace = name }
+        @transformer = transformer
       end
 
       # Sends events to statsd instance
+      # If the event's value field is a hash, this will send multiple events
+      # to statsd with the original name suffixed by the name of the events
+      # in the hash
       def process(event)
-        if(event.respond_to?(:duration))
-          @statsd.timing(event.name, event.duration)
-        elsif(event.respond_to?(:value))
-          @statsd.gauge(event.name, event.value)
+        if event.is_a?(Hallmonitor::TimedEvent)
+          process_timed_event(event)
+        elsif event.is_a?(Hallmonitor::GaugeEvent)
+          process_gauge_event(event)
+        else
+          process_event(event)
+        end
+      end
+
+      private
+
+      def process_timed_event(event)
+        event_name = name_for(event)
+        if event.duration.is_a?(Hash)
+          event.duration.each do |name, value|
+            @statsd.timing("#{event_name}.#{name}", value)
+          end
         else
-          @statsd.count(event.name, event.count)
+          @statsd.timing(event_name, event.duration)
         end
       end
 
+      def process_gauge_event(event)
+        event_name = name_for(event)
+        if event.value.is_a?(Hash)
+          event.value.each do |name, value|
+            @statsd.gauge("#{event_name}.#{name}", value)
+          end
+        else
+          @statsd.gauge(event_name, event.value)
+        end
+      end
+
+      def process_event(event)
+        event_name = name_for(event)
+        if event.count.is_a?(Hash)
+          event.count.each do |name, value|
+            @statsd.count("#{event_name}.#{name}", value)
+          end
+        else
+          @statsd.count(event_name, event.count)
+        end
+      end
+
+      def name_for(event)
+        @transformer ? @transformer.transform(event) : event.name
+      end
     end
   end
 end

data/lib/hallmonitor/timed_event.rb

@@ -10,8 +10,9 @@ module Hallmonitor
 
     # Builds a new {TimedEvent}
     # @param name [String] name of this event
-    # @param duration [Number] the timespan of this event
-    def initialize(name, duration=nil, tags: {})
+    # @param duration [Number, Hash] the timespan of this event, or multiple named
+    #   timestamps
+    def initialize(name, duration: nil, tags: {})
       super(name, tags: tags)
       @duration = duration
     end
@@ -39,7 +40,7 @@ module Hallmonitor
         time: @time,
         start: @start,
         stop:  @stop,
-        duration: self.duration
+        duration: duration
       }.to_json(*a)
     end
   end

data/lib/hallmonitor/version.rb

@@ -1,10 +1,10 @@
 module Hallmonitor
   module Version
-    MAJOR = 1
-    MINOR = 1
+    MAJOR = 2
+    MINOR = 0
     PATCH = 0
     BUILD = nil
 
-    STRING = [MAJOR,MINOR,PATCH,BUILD].compact.join(".")
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
   end
 end

data/spec/hallmonitor/dispatcher_spec.rb

@@ -24,14 +24,15 @@ module Hallmonitor
       end
 
       describe 'with exception trapping turned off' do
+        let(:error) { "FOOO" }
         before do
-          allow(outputter).to receive(:process).and_raise("FOOOOO")
+          allow(outputter).to receive(:process).and_raise(error)
           Hallmonitor.configure do |c|
             c.trap_outputter_exceptions = false
           end
         end
         it 'raises outputter exceptions' do
-          expect{Dispatcher.output("thing")}.to raise_error
+          expect { Dispatcher.output("thing") }.to raise_error(error)
         end
       end
 

data/spec/hallmonitor/monitored_spec.rb

@@ -86,11 +86,11 @@ RSpec.describe Hallmonitor::Monitored do
       it 'emits a timer for the block' do
         expect(Hallmonitor::Dispatcher).to(
           receive(:output).with(a_timed_event_with_name(name)))
-        expect {
+        expect do
           subject.watch(name) do
-            raise 'OOPS!'
+            fail 'OOPS!'
           end
-        }.to raise_error
+        end.to raise_error('OOPS!')
       end
     end
   end

data/spec/hallmonitor/outputters/influxdb_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'hallmonitor/outputters/influxdb'
+
+module Hallmonitor
+  module Outputters
+    RSpec.describe Influxdb do
+      let(:influxdb_client) { nil }
+      let(:default_tags) { {} }
+      let(:outputter) { described_class.new(influxdb_client, default_tags) }
+
+      context '#initialize' do
+        context 'with a bad influxdb client' do
+          it 'raises an error' do
+            expect { outputter }.to raise_error(String)
+          end
+        end
+
+        context 'with a good client' do
+          let(:influxdb_client) { double('influxdb_client') }
+          before do
+            allow(influxdb_client).to receive(:write_point)
+          end
+
+          it 'does not raise an error' do
+            expect { outputter }.to_not raise_error
+          end
+        end
+      end
+
+      context '#process' do
+        let(:default_tags) { { foo: 'bar' } }
+        let(:influxdb_client) { double('influxdb_client') }
+        let(:event_name) { 'event_name' }
+        let(:event) { Hallmonitor::Event.new(event_name, tags: tags) }
+        let(:tags) { { tag_one: 'one', tag_two: 'two' } }
+        let(:expected_value) { event.count }
+        let(:expected_type) { 'count' }
+        let(:expected_data) do
+          {
+            values: { value: expected_value },
+            tags: default_tags.merge(tags).merge(type: expected_type)
+          }
+        end
+
+        it 'sends the correct information to influxdb' do
+          expect(influxdb_client).to(
+            receive(:write_point).with(event_name, expected_data))
+          outputter.process(event)
+        end
+
+        context 'with a timer event' do
+          let(:event) { Hallmonitor::TimedEvent.new(event_name, duration: 100, tags: tags) }
+          let(:expected_value) { event.duration }
+          let(:expected_type) { 'timer' }
+          it 'sends the correct information to influxdb' do
+            expect(influxdb_client).to(
+              receive(:write_point).with(event_name, expected_data))
+            outputter.process(event)
+          end
+        end
+
+        context 'with a gauge event' do
+          let(:event) { Hallmonitor::GaugeEvent.new(event_name, value: 100, tags: tags) }
+          let(:expected_value) { event.value }
+          let(:expected_type) { 'gauge' }
+          it 'sends the correct information to influxdb' do
+            expect(influxdb_client).to(
+              receive(:write_point).with(event_name, expected_data))
+            outputter.process(event)
+          end
+        end
+
+        context 'with a name transformer' do
+          let(:transformer) { double('name_transformer') }
+          let(:outputter) do
+            described_class.new(influxdb_client, default_tags, transformer)
+          end
+
+          it 'builds event information using the transformer' do
+            expect(transformer).to(
+              receive(:transform)
+              .with(event.name)
+              .and_return(
+                name: 'foo',
+                tags: { additional: 'foo' }
+              )
+            )
+            expected_data[:tags][:additional] = 'foo'
+            expect(influxdb_client).to(
+              receive(:write_point).with('foo', expected_data))
+            outputter.process(event)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/hallmonitor/outputters/statsd_outputter_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+require 'hallmonitor/outputters/statsd_outputter'
+
+module Hallmonitor
+  module Outputters
+    RSpec.describe StatsdOutputter do
+      let(:statsd_client) { instance_double(Statsd) }
+      let(:prefix) { 'test' }
+      let(:outputter) { described_class.new(prefix) }
+
+      before do
+        allow(statsd_client).to receive(:namespace=)
+        allow(Statsd).to receive(:new).and_return(statsd_client)
+      end
+
+      it 'can be instantiated' do
+        expect { outputter }.to_not raise_error
+      end
+
+      context '#process' do
+        let(:event_name) { 'foo.bar.baz' }
+        context 'with an event' do
+          let(:event) { Event.new(event_name) }
+
+          it 'sends the event to statsd' do
+            expect(statsd_client).to receive(:count).with(event_name, event.count)
+            outputter.process(event)
+          end
+
+          context 'that has multiple values' do
+            let(:values) { { foo: 1, bar: 2 } }
+            let(:event) { Event.new(event_name, count: values) }
+            it 'sends multiple events to statsd' do
+              expect(statsd_client).to receive(:count).with("#{event_name}.foo", event.count[:foo])
+              expect(statsd_client).to receive(:count).with("#{event_name}.bar", event.count[:bar])
+              outputter.process(event)
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hallmonitor
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Chris TenHarmsel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-24 00:00:00.000000000 Z
+date: 2016-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -167,6 +167,8 @@ files:
 - lib/hallmonitor/version.rb
 - spec/hallmonitor/dispatcher_spec.rb
 - spec/hallmonitor/monitored_spec.rb
+- spec/hallmonitor/outputters/influxdb_spec.rb
+- spec/hallmonitor/outputters/statsd_outputter_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/epchris/hallmonitor
 licenses:
@@ -188,12 +190,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Simple Ruby Event Monitoring
 test_files:
 - spec/hallmonitor/dispatcher_spec.rb
 - spec/hallmonitor/monitored_spec.rb
+- spec/hallmonitor/outputters/influxdb_spec.rb
+- spec/hallmonitor/outputters/statsd_outputter_spec.rb
 - spec/spec_helper.rb
 has_rdoc: