hallmonitor 4.2.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d6589305a3290c2bf628e2a55f5ca6d13d4616b
-  data.tar.gz: 1e616bf4cb119aae142a64c4f70a6b043d5bf8a4
+  metadata.gz: 54c0631a67fb95ae8201691fdd5e5e12c09936f1
+  data.tar.gz: d0dddea0967b40bfeea62612157649eeef033711
 SHA512:
-  metadata.gz: 3233ea964e32edbe665230f4f32e434b4988acacce629b12ae763d2313d7d5ef3a549e1f37af6685c3f4c8cf93f1870c33e7963925f70b11284869591f0518b2
-  data.tar.gz: 565ec6ba834afa8b0e81296a38df618c09ba759682d928b0ae69ec11301e6e8c7b3bd02f2800391b3c5be460f57288bc9eae3ecfd11920d9b0c2a15c3f01f515
+  metadata.gz: 0e314315927b4dbaa450022ac88e054ff6e1e230a5f81db0930cab21e54c7e28d20d3521d17cce6671897f1837f8ad7a400409038f7e0a2e8e34e4da4e721045
+  data.tar.gz: 193b9d428e2cca3a95618f5a8b77853fefd8194673f2bf83ef8937326c05c0c47ad667c5328372a99845c4ae862b4f6acf948a77ec1e64b8de9e3721ceff5349

data/README.md

@@ -2,21 +2,32 @@
 
 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.
-It also includes support for outputting events to InfluxDB if the 'influxdb' gem is installed.
+Hallmonitor includes support for the following outputters:
+
+- [Statsd](https://github.com/reinh/statsd) - Requires the `statsd` gem to be installed
+- [InfluxDB](https://github.com/influxdata/influxdb-ruby) - Requires the `influxdb` gem to be installed
+- [Datadog](https://github.com/DataDog/dogstatsd-ruby) - Requires the `dogstatsd-ruby` gem to be installed
+- IOOutputter - Simple outputter that outputs to an IO object
+- [NewRelic](https://github.com/newrelic/rpm) - Requires the `newrelic_rpm` gem to be installed
+
 
 ## Setup
 Before you can use Hallmonitor you have to do a tiny bit of configuration in the form of adding outputters.
 
 ```ruby
 # Add an outputter to STDOUT
+require 'hallmonitor/outputters/iooutputter.rb'
 Hallmonitor.add_outputter Hallmonitor::Outputters::IOOutputter.new("STDOUT", STDOUT)
 
 # Add an outputter to StatsD
+require 'hallmonitor/outputters/statsd_outputter'
 Hallmonitor.add_outputter Hallmonitor::Outputters::StatsdOutputter.new("example", "localhost")
-```
 
-The `StatsdOutputter` is only available if you've installed the `statsd-ruby` gem.  If it's not available, StatsdOutputter's intitialize method will raise a RuntimeError
+# Add an outputter to Datadog
+require 'hallmonitor/outputters/datadog
+datadog = Datadog::Statsd.new
+Hallmonitor.add_outputter Hallmonitor::Outputters::Datadog.new(datadog)
+```
 
 ## Configuration
 Right now there's only one configuration option and here's how you can set it:
@@ -90,5 +101,5 @@ event.emit
 
 ## Copyright
 
-Copyright (c) 2012-2015 Chris TenHarmsel. See LICENSE.txt for
+Copyright (c) 2012-2018 Chris TenHarmsel. See LICENSE.txt for
 further details.

data/lib/hallmonitor/gauge_event.rb

@@ -21,5 +21,13 @@ module Hallmonitor
       self.count = new_value
     end
 
+    def to_json(*a)
+      {
+        name: name,
+        time: time,
+        value: count,
+        tags: tags
+      }.to_json(*a)
+    end
   end
 end

data/lib/hallmonitor/monitored.rb

@@ -9,16 +9,18 @@ module Hallmonitor
       # @options [Hash] Optional settings:
       #   metric_name: [String] Metric name to emit, defaults to
       #   "#{underscore(name)}.#{method_sym}"
-      def timer_for(method_sym, options = {})
-        metric_name = options[:metric_name] || "#{underscore(name)}.#{method_sym}"
-        send(:define_method, "#{method_sym}_with_hallmonitor_timer") do |*args|
-          watch(metric_name) do
-            send("#{method_sym}_without_hallmonitor_timer".to_sym, *args)
+      def timer_for(method_sym, metric_name: nil, tags: {})
+        metric_name ||= "#{underscore(name)}.#{method_sym}"
+        undecorated_method_sym = "#{method_sym}_without_hallmonitor_timer".to_sym
+        decorated_method_sym = "#{method_sym}_with_hallmonitor_timer".to_sym
+        send(:define_method, decorated_method_sym) do |*args|
+          watch(metric_name, tags: tags) do
+            send(undecorated_method_sym, *args)
           end
         end
 
-        alias_method "#{method_sym}_without_hallmonitor_timer".to_sym, method_sym
-        alias_method method_sym, "#{method_sym}_with_hallmonitor_timer".to_sym
+        alias_method undecorated_method_sym, method_sym
+        alias_method method_sym, decorated_method_sym
       end
 
       # Sets up a counter for a method by symbol.  Method must have already been
@@ -27,17 +29,20 @@ module Hallmonitor
       # @options [Hash] Optional settings:
       #   metric_name: [String] Metric name to emit, defaults to
       #   "#{underscore(name)}.#{method_sym}"
-      def count_for(method_sym, options = {})
-        metric_name = options[:metric_name] || "#{underscore(name)}.#{method_sym}"
-        send(:define_method, "#{method_sym}_with_hallmonitor_counter") do |*args|
-          emit(metric_name)
-          send("#{method_sym}_without_hallmonitor_counter".to_sym, *args)
+      def count_for(method_sym, metric_name: nil, tags: {})
+        metric_name ||= "#{underscore(name)}.#{method_sym}"
+        undecorated_method_sym = "#{method_sym}_without_hallmonitor_counter".to_sym
+        decorated_method_sym = "#{method_sym}_with_hallmonitor_counter".to_sym
+        send(:define_method, decorated_method_sym) do |*args|
+          emit(metric_name, tags: tags)
+          send(undecorated_method_sym, *args)
         end
 
-        alias_method "#{method_sym}_without_hallmonitor_counter".to_sym, method_sym
-        alias_method method_sym, "#{method_sym}_with_hallmonitor_counter".to_sym
+        alias_method undecorated_method_sym, method_sym
+        alias_method method_sym, decorated_method_sym
       end
 
+      # :reek:UtilityFunction
       def underscore(value)
         word = value.dup
         word.gsub!(/::/, '.')
@@ -51,17 +56,19 @@ module Hallmonitor
 
     def self.included(base)
       base.extend(ClassMethods)
+      base.extend(self)
     end
 
-    # Emits an event: self if the event param is nil, the passed in event if
-    # it's an {Event}, or constructs a {Event} from the passed in param.
+    # Emits an event: self if the event param is nil, the passed in
+    # event if it's an {Event}, or constructs a {Event} from the
+    # passed in param.
+    #
+    # If the parameter is a {Hallmonitor::Event}, it will be emitted
+    # as is.  Otherwise, a new {Hallmonitor::Event} will be created
+    # with the parameter and emitted.
     #
-    # If the parameter is a {Hallmonitor::Event}, it will be emitted as is.
-    # Otherwise, a new {Hallmonitor::Event} will be created with the parameter
-    # and emitted.
     # @param event [Mixed] The thing to emit, see method description
     # @yield [to_emit] The thing that's going to be emitted
-    # @return nil
     def emit(event = nil, tags: {})
       to_emit = self
       unless event.nil?

data/lib/hallmonitor/outputters/datadog.rb

@@ -0,0 +1,82 @@
+begin
+  require 'datadog/statsd'
+rescue LoadError
+end
+
+module Hallmonitor
+  module Outputters
+    # An outputter for Dogstatsd
+    class Datadog < Outputter
+      # Simple EventData struct
+      EventData = Struct.new(:name, :value, :tags, :type)
+
+      # Builds a new DogstatsdOutputter.
+      # @param dogstatsd [Datadog::Statsd] Dogstatd client instance to use
+      # @param tags [Hash] Default tags to apply to all metrics sent to this outputter
+      def initialize(dogstatsd, tags: {})
+        super('dogstatsd')
+        @tags = {}.merge(tags)
+        @statsd = dogstatsd
+      end
+
+      # Sends events to datadog 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)
+        event_data = build_event_data(event)
+        write(event_data)
+      end
+
+      private
+
+      # :reek:FeatureEnvy
+      def write(event_data)
+        event_data.each do |data|
+          @statsd.send(data.type, data.name, data.value, tags: data.tags)
+        end
+      end
+
+      def build_event_data(event)
+        case event
+        when Hallmonitor::TimedEvent
+          build_timed_data(event)
+        when Hallmonitor::GaugeEvent
+          build_gauge_data(event)
+        else
+          build_count_data(event)
+        end
+      end
+
+      def build_timed_data(event)
+        build_data(event, event.duration, :timing)
+      end
+
+      def build_gauge_data(event)
+        build_data(event, event.value, :gauge)
+      end
+
+      def build_count_data(event)
+        build_data(event, event.count, :count)
+      end
+
+      # :reek:FeatureEnvy
+      def build_data(event, value, type)
+        event_name = event.name
+        tags = process_tags(event.tags)
+        if value.is_a?(Hash)
+          value.map do |name, value|
+            EventData.new("#{event_name}.#{name}", value, tags, type)
+          end
+        else
+          [EventData.new(event_name, value, tags, type)]
+        end
+      end
+
+      def process_tags(tags)
+        @tags.merge(tags).map { |key, value| "#{key}:#{value}" }
+      end
+    end
+  end
+end

data/lib/hallmonitor/timed_event.rb

@@ -36,11 +36,12 @@ module Hallmonitor
 
     def to_json(*a)
       {
-        name: @name,
-        time: @time,
+        name: name,
+        time: time,
         start: @start,
         stop:  @stop,
-        duration: duration
+        duration: duration,
+        tags: tags
       }.to_json(*a)
     end
   end

data/lib/hallmonitor/version.rb

@@ -1,7 +1,7 @@
 module Hallmonitor
   module Version
-    MAJOR = 4
-    MINOR = 2
+    MAJOR = 5
+    MINOR = 0
     PATCH = 0
     BUILD = nil
 

data/spec/hallmonitor/monitored_spec.rb

@@ -6,24 +6,28 @@ class Thing
   def timer_for_test
     # Nothing
   end
-  timer_for :timer_for_test
+  timer_for :timer_for_test, metric_name: 'thing.measure', tags: {foo: 'bar'}
 
   def count_for_test
     # Nothing
   end
-  count_for :count_for_test
+  count_for :count_for_test, metric_name: 'thing.execute', tags: {foo: 'bar'}
 end
 
-RSpec::Matchers.define :an_event_with_name do |expected_name|
-  match { |actual| actual.is_a?(Hallmonitor::Event) && actual.name == expected_name }
+RSpec::Matchers.define :an_event do
+  match { |actual| actual.is_a?(Hallmonitor::Event)}
 end
 
-RSpec::Matchers.define :an_event_with_tags do |expected_tags|
-  match { |actual| actual.is_a?(Hallmonitor::Event) && actual.tags == expected_tags}
+RSpec::Matchers.define :a_timed_event do
+  match { |actual| actual.is_a?(Hallmonitor::Event)}
 end
 
-RSpec::Matchers.define :a_timed_event_with_name do |expected_name|
-  match { |actual| actual.is_a?(Hallmonitor::TimedEvent) && actual.name == expected_name }
+RSpec::Matchers.define :has_name do |expected_name|
+  match { |actual| actual.name == expected_name }
+end
+
+RSpec::Matchers.define :has_tags do |expected_tags|
+  match { |actual| actual.tags == expected_tags}
 end
 
 RSpec.describe Hallmonitor::Monitored do
@@ -32,7 +36,11 @@ RSpec.describe Hallmonitor::Monitored do
   describe '#timer_for' do
     it 'emits a timer with an appropriate name' do
       expect(Hallmonitor::Dispatcher).to(
-        receive(:output).with(a_timed_event_with_name('thing.timer_for_test')))
+        receive(:output)
+          .with(
+            a_timed_event.and(has_name('thing.measure')).and(has_tags({foo: 'bar'}))
+          )
+      )
       Thing.new.timer_for_test
     end
   end
@@ -40,33 +48,33 @@ RSpec.describe Hallmonitor::Monitored do
   describe '#count_for' do
     it 'emits an event with an appropriate name' do
       expect(Hallmonitor::Dispatcher).to(
-        receive(:output).with(an_event_with_name('thing.count_for_test')))
+        receive(:output).with(
+          an_event.and(has_name('thing.execute')).and(has_tags({foo: 'bar'}))
+        )
+      )
       Thing.new.count_for_test
     end
   end
 
-  describe '#watch' do
+  shared_examples 'for watch' do
     let(:retval) { 'Hello World' }
     let(:name) { 'foo' }
 
     it 'returns the value the block returns' do
-      value = subject.watch(name) do
-        retval
-      end
+      value = subject.watch(name) { retval }
       expect(value).to eq(retval)
 
-      value = subject.watch(name) do
-        nil
-      end
+      value = subject.watch(name) { nil }
       expect(value).to_not be
     end
 
     it 'emits a timer event for the block' do
       expect(Hallmonitor::Dispatcher).to(
-        receive(:output).with(a_timed_event_with_name(name)))
-      subject.watch(name) do
-        'foo'
-      end
+        receive(:output).with(
+          an_event.and(has_name(name))
+        )
+      )
+      subject.watch(name) { 'foo' }
     end
 
     describe 'with tags' do
@@ -75,44 +83,53 @@ RSpec.describe Hallmonitor::Monitored do
 
       it 'emits an event with tags' do
         expect(Hallmonitor::Dispatcher).to(
-          receive(:output).with(an_event_with_tags(tags)))
-        subject.watch(name, tags: tags) do
-          'foo'
-        end
+          receive(:output).with(
+            an_event.and(has_tags(tags))
+          )
+        )
+        subject.watch(name, tags: tags) { 'foo' }
       end
     end
 
     describe 'when the block raises an error' do
       it 'emits a timer for the block' do
         expect(Hallmonitor::Dispatcher).to(
-          receive(:output).with(a_timed_event_with_name(name)))
+          receive(:output).with(
+            a_timed_event.and(has_name(name))
+          )
+        )
         expect do
-          subject.watch(name) do
-            fail 'OOPS!'
-          end
+          subject.watch(name) { fail 'OOPS!' }
         end.to raise_error('OOPS!')
       end
     end
   end
 
-  describe '#emit' do
+  shared_examples 'for emit' do
     describe 'with a string parameter' do
       let(:name) { 'foo' }
 
       it 'emits an event with the passed in name' do
         expect(Hallmonitor::Dispatcher).to(
-          receive(:output).with(an_event_with_name(name)))
+          receive(:output).with(
+            an_event.and(has_name(name))
+          )
+        )
+
         subject.emit(name)
       end
     end
 
     describe 'with tags' do
       let(:name) { 'foo'}
-      let(:tags) { {'foo': 'bar', 'baz': 6}}
+      let(:tags) { {'foo' => 'bar', 'baz' => 6}}
 
       it 'emits an event with tags' do
         expect(Hallmonitor::Dispatcher).to(
-          receive(:output).with(an_event_with_tags(tags)))
+          receive(:output).with(
+            an_event.and(has_tags(tags)).and(has_name(name))
+          )
+        )
         subject.emit(name, tags: tags)
       end
     end
@@ -139,6 +156,27 @@ RSpec.describe Hallmonitor::Monitored do
         subject.emit(event)
       end
     end
+  end
 
+  context 'Instance' do
+    subject { Thing.new }
+    context '#watch' do
+      include_examples 'for watch'
+    end
+
+    context '#emit' do
+      include_examples 'for emit'
+    end
+  end
+
+  context 'Class' do
+    subject { Thing }
+    context '.watch' do
+      include_examples 'for watch'
+    end
+
+    context '.emit' do
+      include_examples 'for emit'
+    end
   end
 end

data/spec/hallmonitor/outputters/datadog_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'hallmonitor/outputters/datadog'
+
+module Hallmonitor
+  module Outputters
+    RSpec.describe Datadog do
+      let(:dogstatsd_client) { instance_double(::Datadog::Statsd) }
+      let(:outputter) { described_class.new(dogstatsd_client) }
+
+      it 'can be instantiated' do
+        expect { outputter }.to_not raise_error
+      end
+
+      context '#process' do
+        let(:event_name) { 'foo.bar.baz' }
+        let(:event_tags) { { foo: 'bar' } }
+        let(:event_tags_expected) { { tags: ['foo:bar'] } }
+
+        context 'with a timed event' do
+          let(:event) { TimedEvent.new(event_name, duration: 100, tags: event_tags) }
+
+          it 'sends the event to statsd' do
+            expect(dogstatsd_client).to(
+              receive(:timing)
+                .with(event_name, event.duration, event_tags_expected)
+            )
+            outputter.process(event)
+          end
+        end
+
+        context 'with an event' do
+          let(:event) { Event.new(event_name, tags: event_tags) }
+
+          it 'sends the event to statsd' do
+            expect(dogstatsd_client).to(
+              receive(:count)
+                .with(event_name, event.count, event_tags_expected)
+            )
+            outputter.process(event)
+          end
+
+          context 'that has multiple values' do
+            let(:values) { { foo: 1, bar: 2 } }
+            let(:event) do
+              Event.new(event_name, count: values, tags: event_tags)
+            end
+
+            it 'sends multiple events to statsd' do
+              expect(dogstatsd_client).to(
+                receive(:count)
+                  .with(
+                    "#{event_name}.foo",
+                    event.count[:foo],
+                    event_tags_expected
+                  )
+              )
+              expect(dogstatsd_client).to(
+                receive(:count)
+                  .with(
+                    "#{event_name}.bar",
+                    event.count[:bar],
+                    event_tags_expected
+                  )
+              )
+              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: 4.2.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Chris TenHarmsel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-23 00:00:00.000000000 Z
+date: 2018-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: statsd-ruby
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: dogstatsd-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -67,21 +67,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.2.2
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,35 +95,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -137,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: statsd-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -157,15 +157,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".document"
-- ".gitignore"
-- CHANGELOG.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- bin/example.rb
-- hallmonitor.gemspec
 - lib/hallmonitor.rb
 - lib/hallmonitor/configuration.rb
 - lib/hallmonitor/dispatcher.rb
@@ -174,7 +167,7 @@ files:
 - lib/hallmonitor/middleware.rb
 - lib/hallmonitor/monitored.rb
 - lib/hallmonitor/outputter.rb
-- lib/hallmonitor/outputters/dogstatsd_outputter.rb
+- lib/hallmonitor/outputters/datadog.rb
 - lib/hallmonitor/outputters/influxdb.rb
 - lib/hallmonitor/outputters/iooutputter.rb
 - lib/hallmonitor/outputters/new_relic.rb
@@ -183,7 +176,7 @@ files:
 - lib/hallmonitor/version.rb
 - spec/hallmonitor/dispatcher_spec.rb
 - spec/hallmonitor/monitored_spec.rb
-- spec/hallmonitor/outputters/dogstatsd_outputter_spec.rb
+- spec/hallmonitor/outputters/datadog_spec.rb
 - spec/hallmonitor/outputters/influxdb_spec.rb
 - spec/hallmonitor/outputters/statsd_outputter_spec.rb
 - spec/spec_helper.rb
@@ -207,15 +200,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Simple Ruby Event Monitoring
 test_files:
-- spec/hallmonitor/dispatcher_spec.rb
+- spec/spec_helper.rb
 - spec/hallmonitor/monitored_spec.rb
-- spec/hallmonitor/outputters/dogstatsd_outputter_spec.rb
+- spec/hallmonitor/outputters/datadog_spec.rb
 - spec/hallmonitor/outputters/influxdb_spec.rb
 - spec/hallmonitor/outputters/statsd_outputter_spec.rb
-- spec/spec_helper.rb
-has_rdoc: 
+- spec/hallmonitor/dispatcher_spec.rb

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/.gitignore

@@ -1,50 +0,0 @@
-# rcov generated
-coverage
-coverage.data
-
-# rdoc generated
-rdoc
-
-# yard generated
-doc
-.yardoc
-
-# bundler
-.bundle
-
-# jeweler generated
-pkg
-
-# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
-#
-# * Create a file at ~/.gitignore
-# * Include files you want ignored
-# * Run: git config --global core.excludesfile ~/.gitignore
-#
-# After doing this, these files will be ignored in all your git projects,
-# saving you from having to 'pollute' every project you touch with them
-#
-# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
-#
-# For MacOS:
-#
-#.DS_Store
-
-# For TextMate
-#*.tmproj
-#tmtags
-
-# For emacs:
-#*~
-#\#*
-#.\#*
-
-# For vim:
-#*.swp
-
-# For redcar:
-#.redcar
-
-# For rubinius:
-#*.rbc
-Gemfile.lock

data/CHANGELOG.md

@@ -1,17 +0,0 @@
-# Verison 4.2.0
-- Added Dogstatsd outputter, thanks to mlahaye
-
-# Version 4.0.0
-- Changed initializer signature for InfluxDB outputter to use
-  keyword args.
-- Added `attr_accessor` for InfluxDB Outputter's transformer
-
-# Version 3.0.0
-- Refactored the Transformer concept in the InfluxDB outputter so that
-  it is more flexible. This was in response to the InfluxDB client gem
-  "fixing" a bug where numerical values were previously always sent as
-  floats, now numbers are marked as "integer" type if they are ruby
-  Integers which can lead to some field-type conflicts if you update
-  your InfluxDB gem version and were previously sending integers at
-  floats.  Using the Transformer now allows you to modify the values
-  that will be sent to InfluxDB immediately before they're sent out.x

data/Gemfile

@@ -1,3 +0,0 @@
-source "http://rubygems.org"
-
-gemspec

data/Rakefile

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'rubygems'
-require 'bundler/gem_tasks'
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec)
-task :default => :spec
-
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "hallmonitor #{Hallmonitor::Version::STRING}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/bin/example.rb

@@ -1,49 +0,0 @@
-#!/usr/bin/env ruby
-
-lib = File.expand_path('../../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'hallmonitor'
-require 'hallmonitor/outputters/iooutputter'
-require 'hallmonitor/outputters/statsd_outputter'
-require 'pry'
-
-Hallmonitor.add_outputter Hallmonitor::Outputters::IOOutputter.new("STDOUT", STDOUT)
-Hallmonitor.add_outputter Hallmonitor::Outputters::StatsdOutputter.new("example", "localhost")
-
-class Foo
-  include Hallmonitor::Monitored
-
-  def do_something
-    sleep_time_ms = ((Random.rand * 100).floor) * 2
-    puts "Sleeping for #{sleep_time_ms} milliseconds"
-    sleep(sleep_time_ms / 1000.0)
-  end
-  timer_for :do_something
-  count_for :do_something
-
-  def emit_events(count=30)
-    # Emit 100 events
-    count.times do
-      emit("event")
-      sleep(1)
-    end
-  end
-
-  def time_me
-    watch("timed") do |x|
-      sleep(5)
-    end
-  end
-end
-
-f = Foo.new
-
-puts 'Calling method with timer_for and count_for...'
-f.do_something
-
-puts 'Emitting some events'
-f.emit_events(5)
-
-puts 'Timing a 5 second block'
-f.time_me

data/hallmonitor.gemspec

@@ -1,31 +0,0 @@
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'hallmonitor/version'
-
-Gem::Specification.new do |s|
-  s.name = "hallmonitor"
-  s.version = Hallmonitor::Version::STRING
-
-  s.authors = ["Chris TenHarmsel"]
-  s.summary = "Simple Ruby Event Monitoring"
-  s.description = "Hallmonitor is a simple event monitoring framework in Ruby"
-  s.email = ["chris@tenharmsel.com"]
-  s.homepage = "http://github.com/epchris/hallmonitor"
-  s.licenses = ["MIT"]
-
-  s.files = `git ls-files`.split($/)
-  s.test_files = s.files.grep(%r{^(test|spec|features)/})
-  s.require_paths = ["lib"]
-
-  s.add_runtime_dependency("json", [">= 0"])
-
-  s.add_development_dependency("statsd-ruby", [">= 0"])
-  s.add_development_dependency("dogstatsd-ruby", [">= 0"])
-  s.add_development_dependency("influxdb", ["~> 0.2.2"])
-  s.add_development_dependency("rspec", [">= 3.0"])
-  s.add_development_dependency("rdoc", [">= 0"])
-  s.add_development_dependency("bundler", ["~> 1.3"])
-  s.add_development_dependency("pry-byebug", [">= 0"])
-  s.add_development_dependency("rake", [">= 0"])
-  s.add_development_dependency("yard", [">= 0"])
-end

data/lib/hallmonitor/outputters/dogstatsd_outputter.rb

@@ -1,85 +0,0 @@
-begin
-  require 'datadog/statsd'
-rescue LoadError
-end
-
-module Hallmonitor
-  module Outputters
-    # An outputter for Dogstatsd
-    class DogstatsdOutputter < Outputter
-      # Builds a new DogstatsdOutputter.
-      # @param prefix [String] Prefix for all events output by this outputter,
-      #   the prefix will be applied to all event names before sending to statsd
-      # @param host [String] Datadog Host, defaults to '127.0.0.1'
-      # @param port [Number] Datadog Port, defaults to 8125
-      # @raise if Datadog::Statsd is undefined (Gem not present)
-      def initialize(prefix, host = '127.0.0.1', port = 8125, tags: {})
-        unless defined?(Datadog::Statsd)
-          fail 'In order to use DogstatsdOutputter, dogstatsd-ruby gem must be installed'
-        end
-
-        super(prefix)
-        @tags = {}.merge(tags)
-        @statsd = Datadog::Statsd.new(host).tap { |sd| sd.namespace = name }
-      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_tags(tags)
-        @tags.merge(tags).map {|key, value| "#{key}:#{value}"}
-      end
-
-      def process(event)
-        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, tags: process_tags(event.tags))
-          end
-        else
-          @statsd.timing(event_name, event.duration, tags: process_tags(event.tags))
-        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, tags: process_tags(event.tags))
-          end
-        else
-          @statsd.gauge(event_name, event.value, tags: process_tags(event.tags))
-        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, tags: process_tags(event.tags))
-          end
-        else
-          @statsd.count(event_name, event.count, tags: process_tags(event.tags))
-        end
-      end
-
-      def name_for(event)
-        event.name
-      end
-    end
-  end
-end

data/spec/hallmonitor/outputters/dogstatsd_outputter_spec.rb

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