nosey 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+.DS_Store
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in nosey.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,10 @@
+guard 'rspec', :version => 2, :bundler => true, :cli => '--colour --format nested --debugger' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec/" }
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end

data/README.md

@@ -0,0 +1,59 @@
+
+              |     |
+              |     |
+             /       \
+            ( __   __ )   Nosey - Realtime Ruby app instrumentation.
+             '--'-;  ;
+                  |  |
+            _     |  |
+       __ /` ``""-;_ |
+       \ '.;------. `\
+        | |    __..  |
+        | \.-''   _  |
+        | |  ,-'-,   |
+        |  \__.-'    |
+         \    '.    /
+          \     \  /
+           '.      |
+        jgs  )     |
+
+Nosey is a way to instrument your Evented Ruby applications to track counts, aggregates, etc. It was built a Poll Everywhere because we need a way to peer into our Evented apps and grab some basic statistics so that we could graph on Munin. Since we needed this instrumentation available in several EM projects, we gathered the basics up into this gem.
+
+## Getting Started
+
+Install the gem.
+
+    gem install nosey
+
+Instrument your Ruby app with nosey.
+
+    require 'nosey'
+    
+    class PandaBear
+      include Nosey::Instrumentation
+
+      def initialize
+        nosey.touch 'started_at'
+      end
+
+      def growl
+        nosey.increment 'growls'
+        nosey.touch 'last_growled_at'
+        "Grrrrr!"
+      end
+    end
+    
+    princess = PandaBear.new
+    princess.growl
+    princess.nosey.report  # Soon to be a fantastico report, prolly in YML
+
+When you fire Ruby this up, Nosey will open up a socket and report the stats.
+
+    $ cat /tmp/panda_bear.rb.socket
+    
+    panda_bear.rb:
+      started_at: 2011-09-13 23:21:52.530452000 -07:00
+      last_growled_at: 2011-09-13 23:21:52.530452000 -07:00
+      growls: 1
+
+Thats the plan anyway. For now this is only going to work in EM, so its super handy if you're building EM servers and want to dump out the stats.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/nosey/version.rb

@@ -0,0 +1,3 @@
+module Nosey
+  VERSION = "0.0.1"
+end

data/lib/nosey.rb

@@ -0,0 +1,237 @@
+require "nosey/version"
+require 'eventmachine'
+
+module EventMachine
+  module Nosey
+    class SocketServer < EventMachine::Connection
+      Host = '/tmp/nosey.socket'
+      Port = nil
+
+      attr_accessor :report
+
+      # Accept a collection of aggregators that we'll use to report our stats.
+      def initialize(report)
+        @report = report
+      end
+
+      # Dump out the stats and close down the connection
+      def post_init
+        begin
+          send_data report.to_s
+        rescue => e
+          send_data "Exception! #{e}\n#{e.backtrace}"
+        ensure
+          close_connection
+        end
+      end
+
+      # A nice short-cut for peeps who aren't familar with EM to fire up
+      # an Reporting server with an array of aggregators, host, and a port.
+      def self.start(report, host=SocketServer::Host, port=SocketServer::Port)
+        EventMachine::start_server(host, port, self, report)
+      end
+    end
+  end
+end
+
+module Nosey
+  class Report
+    attr_reader :probe_sets
+
+    def initialize
+      yield self if block_given?
+      self
+    end
+
+    def probe_sets
+      @probe_sets ||= Array.new
+    end
+
+    # Hash representation of all the probe_sets. This gives is an intermediate
+    # format that we can parse from other systems or code that needs reporting
+    # data for formatting, or whatever.
+    def to_hash
+      probe_sets.inject({}) do |report, set|
+        report[set.name.to_s] = set.probes.inject({}) do |memo, (_, probe)|
+          memo[probe.name] = probe.value
+          memo
+        end
+        report
+      end
+    end
+
+    # String representation of all the probe_sets that's suitable for 
+    # flushing out over a socket.
+    def to_s
+      to_hash.to_yaml
+    end
+  end
+
+  module Instrumentation
+    # Inject nosey instrumentation into the owning class.
+    def self.included(base)
+      base.send :include, DSL::InstanceMethods
+    end
+
+    module DSL
+      module InstanceMethods
+        # Setup instrumentation that we'll use to report stats for this thing
+        def nosey
+          @_nosey ||= Nosey::Probe::Set.new("#{self.class.name}##{object_id}")
+        end
+      end
+    end
+  end
+
+  module Probe
+    # Base class for containing key/value pairs in nosey. This class is responsible
+    # for reseting probes.
+    class Base
+      attr_reader :name
+      attr_accessor :value
+
+      def initialize(name=nil, value=nil)
+        @name, @value = name, value
+      end
+
+      # Set the value (don't increment or whateves)
+      def set(value)
+        @value = value
+      end
+
+      # Reset the value to nil
+      def reset
+        @value = nil
+      end
+
+      # Representation of this probe
+      def to_hash
+        { name => value }
+      end
+    end
+
+    # Calulcates a min, max, and avg for a given number of samples
+    class Sampler < Base
+      attr_reader :min, :max, :sum, :count
+
+      def initialize(*args)
+        reset
+        super(*args)
+      end
+
+      def sample(value)
+        @min = @max = value unless @min and @max
+
+        @min = value if value < @min
+        @max = value if value > @max
+        @sum   += value
+        @count += 1
+
+        to_hash
+      end
+
+      def avg
+        sum / count if count > 0 and sum
+      end
+
+      def to_hash
+        {
+          'max' => max,
+          'min' => min,
+          'sum' => sum,
+          'avg' => avg,
+          'count' => count
+        }
+      end
+
+      def value
+        to_hash
+      end
+
+      def reset
+        @min = @max = nil
+        @sum = @count = 0
+      end
+    end
+
+    # Count up/down values.
+    class Counter < Base
+      def increment(by=1)
+        change by
+      end
+
+      def decrement(by=1)
+        change -by
+      end
+
+    private
+      def change(by)
+        self.value ||= 0 # Init at 0 if the stat is nil
+        self.value += by
+      end
+    end
+
+    class Touch < Base
+      def touch
+        self.value = Time.now
+      end
+    end
+  end
+
+  # Contains a collection of probes that calculate velocities, counts, etc.
+  class Probe::Set
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      yield self if block_given?
+      self
+    end
+
+    # Increment a counter probe
+    def increment(key,by=1)
+      ensure_probe(Probe::Counter, key).increment(by)
+    end
+
+    # Decrement a counter probe
+    def decrement(key,by=1)
+      ensure_probe(Probe::Counter, key).decrement(by)
+    end
+
+    # Sample a number and get a sum/avg/count/min/max
+    def sample(key,val)
+      ensure_probe(Probe::Sampler, key).sample(val)
+    end
+
+    # Touch a timestamp probe
+    def touch(key)
+      ensure_probe(Probe::Touch, key).touch
+    end
+
+    # List of all the probes that are active
+    def probes
+      @probes ||= Hash.new
+    end
+
+    # Get a probe and do all sorts of crazy stuff to it.
+    def probe(key)
+      probes[key]
+    end
+
+    # Generate a report with this ProbeSet
+    def report
+      Report.new do |r|
+        r.probe_sets << self
+      end
+    end
+
+  private
+    # This factory creates probes based on the methods called from
+    # the instrumentation. If a probe doesn't exist, we create an instance
+    # from the klass and args passed in, then set the thing up in the hash key.
+    def ensure_probe(klass, key, *args)
+      probes[key] ||= klass.new(key, *args)
+    end
+  end
+
+end

data/nosey.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "nosey/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nosey"
+  s.version     = Nosey::VERSION
+  s.authors     = ["Brad Gessler"]
+  s.email       = ["brad@bradgessler.com"]
+  s.homepage    = "https://github.com/polleverywhere/nosey"
+  s.summary     = %q{Instrument Ruby EventMachine applications}
+  s.description = %q{Nosey is a way to instrument your Evented Ruby applications to track counts, aggregates, etc. It was built a Poll Everywhere because we need a way to peer into our Evented apps and grab some basic statistics so that we could graph on Munin. Since we needed this instrumentation available in several EM projects, we gathered the basics up into this gem.}
+
+  s.rubyforge_project = "nosey"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "eventmachine"
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'guard-bundler'
+  s.add_development_dependency 'growl'
+  s.add_development_dependency 'rb-fsevent'
+  s.add_development_dependency 'em-ventually'
+  s.add_development_dependency 'ruby-debug19'
+end

data/spec/lib/nosey_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe EventMachine::Nosey::SocketServer do
+  include EM::Ventually
+
+  before(:each) do
+    @report = Nosey::Report.new do |r|
+      3.times do |n| 
+        r.probe_sets << Nosey::Probe::Set.new("Group #{n}") do |set|
+          set.increment 'hit'
+          set.touch 'generated-at'
+          set.sample 'zie-number', 1
+        end
+      end
+    end
+  end
+
+  it "should write report to socket" do
+    EventMachine::Nosey::SocketServer.start @report
+    Nosey::Test::ReadSocket.start('/tmp/nosey.socket').callback{|data|
+      @response = data
+    }
+    ly{ @response }.test{|response| YAML.load(response).is_a?(Hash) }
+  end
+end
+
+describe Nosey::Report do
+  before(:each) do
+    @report = Nosey::Report.new do |r|
+      3.times do |n| 
+        r.probe_sets << Nosey::Probe::Set.new("Group #{n}") do |set|
+          set.touch 'generated-at'
+          set.increment 'hit'
+        end
+      end
+    end
+  end
+
+  context "report hash" do
+    it "should have groups" do
+      @report.to_hash.keys.should include('Group 0', 'Group 1', 'Group 2')
+    end
+
+    it "should have probes" do
+      @report.to_hash['Group 1'].keys.should include('generated-at', 'hit')
+    end
+  end
+
+  it "should generate report YML for string" do
+    # Spot check for a probe key
+    YAML.load(@report.to_s)['Group 2'].keys.should include('generated-at')
+  end
+end
+
+describe Nosey::Probe::Set do
+  before(:each) do
+    @probes = Nosey::Probe::Set.new("My Probe Set")
+  end
+
+  it "should have name" do
+    @probes.name.should eql("My Probe Set")
+  end
+
+  it "should increment" do
+    @probes.increment('count').should eql(1)
+  end
+
+  it "should decrement" do
+    @probes.decrement('count').should eql(-1)
+  end
+
+  it "should touch" do
+    @probes.touch('touched-at').should be_instance_of(Time)
+  end
+
+  it "should sample" do
+    @probes.sample('foobers', 1).should be_instance_of(Hash)
+  end
+
+  it "should get probe" do
+    @probes.touch('barf')
+    @probes.probe('barf').should be_instance_of(Nosey::Probe::Touch)
+  end
+
+  it "should return report" do
+    @probes.report.probe_sets.first.should eql(@probes)
+  end
+end
+
+describe Nosey::Probe::Counter do
+  before(:all) do
+    @counter = Nosey::Probe::Counter.new
+  end
+
+  it "should init null" do
+    @counter.value.should be_nil
+  end
+
+  it "should increment" do
+    @counter.increment.should eql(1)
+  end
+
+  it "should decrement" do
+    @counter.decrement(2).should eql(-1)
+  end
+
+  it "should set" do
+    @counter.set(0).should eql(0)
+  end
+end
+
+describe Nosey::Probe::Touch do
+  before(:all) do
+    @touch = Nosey::Probe::Touch.new
+  end
+  it "should init null" do
+    @touch.value.should be_nil
+  end
+
+  it "should touch" do
+    @touch.touch
+    @touch.value.should_not be_nil
+  end
+end
+
+describe Nosey::Probe::Sampler do
+  before(:each) do
+    @counter = Nosey::Probe::Sampler.new
+    @counter.sample 1
+    @counter.sample 2
+    @counter.sample 3
+  end
+
+  it "should init hash" do
+    @counter.value.should be_instance_of(Hash)
+  end
+
+  it "should have avg" do
+    @counter.value['avg'].should eql(2)
+  end
+
+  it "should have sum" do
+    @counter.value['sum'].should eql(6)
+  end
+
+  it "should have min" do
+    @counter.value['min'].should eql(1)
+  end
+
+  it "should have max" do
+    @counter.value['max'].should eql(3)
+  end
+
+  it "should have count" do
+    @counter.value['count'].should eql(3)
+  end
+end
+
+
+describe Nosey::Instrumentation do
+  before(:each) do
+    @instance = Nosey::Test::VanillaClass.new
+  end
+
+  it "should have nosey Probe::Set instance" do
+    @instance.nosey.should be_instance_of Nosey::Probe::Set
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+require 'nosey'
+require 'em-ventually'
+require 'socket'
+
+module Nosey
+  module Test
+    class VanillaClass
+      include Nosey::Instrumentation
+
+      def count
+        nosey.count('count')
+      end
+
+      def touch
+        nosey.touch('touched-at')
+      end
+    end
+
+    # Read data from a socket and then kill it right away.
+    class ReadSocket < EventMachine::Connection
+      include EventMachine::Deferrable
+
+      def receive_data(data)
+        buffer << data
+      end
+
+      def unbind
+        succeed buffer
+      end
+
+      def self.start(host,port=nil)
+        EventMachine::connect host, port, self
+      end
+
+    private
+      def buffer
+        @buffer ||= ""
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification 
+name: nosey
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brad Gessler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: guard-bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: growl
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rb-fsevent
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: em-ventually
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug19
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: Nosey is a way to instrument your Evented Ruby applications to track counts, aggregates, etc. It was built a Poll Everywhere because we need a way to peer into our Evented apps and grab some basic statistics so that we could graph on Munin. Since we needed this instrumentation available in several EM projects, we gathered the basics up into this gem.
+email: 
+- brad@bradgessler.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- lib/nosey.rb
+- lib/nosey/version.rb
+- nosey.gemspec
+- spec/lib/nosey_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/polleverywhere/nosey
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: nosey
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Instrument Ruby EventMachine applications
+test_files: 
+- spec/lib/nosey_spec.rb
+- spec/spec_helper.rb