cabin 0.1.8 → 0.2.1

data/lib/cabin/metrics.rb

@@ -0,0 +1,85 @@
+require "cabin/namespace"
+require "cabin/metrics/gauge"
+require "cabin/metrics/meter"
+require "cabin/metrics/counter"
+require "cabin/metrics/timer"
+
+
+
+# What type of metrics do we want?
+#
+# What metrics should come by default?
+# Per-call/transaction/request metrics like:
+#   - hit (count++ type metrics)
+#   - latencies/timings
+#
+# Per app or generally long-lifetime metrics like:
+#   - "uptime"
+#   - cpu usage
+#   - memory usage
+#   - count of active/in-flight actions/requests/calls/transactions
+#   - peer metrics (number of cluster members, etc)
+# ------------------------------------------------------------------
+# https://github.com/codahale/metrics/tree/master/metrics-core/src/main/java/com/yammer/metrics/core
+# Reading what Coda Hale's "Metrics" stuff has, here's my summary:
+#
+#   gauges (callback to return a number)
+#   counters (.inc and .dec methods)
+#   meters (.mark to track each 'hit')
+#     Also exposes 1, 5, 15 minute moving averages
+#   histograms: (.update(value) to record a new value)
+#     like meter, but takes values more than simply '1'
+#     as a result, exposes percentiles, median, etc.
+#   timers
+#     combination of meter + histogram
+#     meter for invocations, histogram for duration
+#
+# With the exception of gauges, all the other metrics are all active/pushed.
+# Gauges take callbacks, so their values are pulled, not pushed. The active
+# metrics can be represented as events since they the update occurs at the
+# time of the change.
+#
+# These active/push metrics can therefore be considered events.
+#
+# All metrics (active/passive) can be queried for 'current state', too,
+# making this suitable for serving to interested parties like monitoring
+# and management tools.
+class Cabin::Metrics
+  include Enumerable
+
+  public
+  def initialize
+    @metrics = {}
+  end # def initialize
+  
+  private
+  def create(instance, name, metric_object)
+    return @metrics[[instance, name]] = metric_object
+  end # def create
+
+  public
+  def counter(instance, name=nil)
+    return create(instance, name, Cabin::Metrics::Counter.new)
+  end # def counter
+
+  public
+  def meter(instance, name=nil)
+    return create(instance, name, Cabin::Metrics::Meter.new)
+  end # def meter
+
+  #public
+  #def histogram(instance, name)
+    #return create(instance, name, Cabin::Metrics::Histogram.new)
+  #end # def histogram
+
+  public
+  def timer(instance, name=nil)
+    return create(instance, name, Cabin::Metrics::Timer.new)
+  end # def timer
+  
+  # iterate over each metric. yields identifer, metric
+  def each(&block)
+    # delegate to the @metrics hash until we need something fancier
+    @metrics.each(&block)
+  end # def each
+end # class Cabin::Metrics

data/lib/cabin/metrics/counter.rb

@@ -0,0 +1,29 @@
+require "cabin/namespace"
+require "thread"
+
+class Cabin::Metrics::Counter
+  # A new Counter. 
+  #
+  # Counters can be incremented and decremented only by 1 at a time..
+  public
+  def initialize
+    @value = 0
+    @lock = Mutex.new
+  end # def initialize
+
+  # increment this counter
+  def incr
+    @lock.synchronize { @value += 1 }
+  end # def incr
+
+  # decrement this counter
+  def decr
+    @lock.synchronize { @value -= 1 }
+  end # def decr
+
+  # Get the value of this metric.
+  public
+  def value
+    return @lock.synchronize { @value }
+  end # def value
+end # class Cabin::Metrics::Counter

data/lib/cabin/metrics/gauge.rb

@@ -0,0 +1,15 @@
+require "cabin/namespace"
+
+class Cabin::Metrics::Gauge
+  # A new Gauge. The block given will be called every time the metric is read.
+  public
+  def initialize(&block)
+    @block = block
+  end # def initialize
+
+  # Get the value of this metric.
+  public
+  def value
+    return @block.call
+  end # def value
+end # class Cabin::Metrics::Gauge

data/lib/cabin/metrics/meter.rb

@@ -0,0 +1,27 @@
+require "cabin/namespace"
+require "thread"
+
+class Cabin::Metrics::Meter
+  # A new Meter 
+  #
+  # Counters can be incremented and decremented only by 1 at a time..
+  public
+  def initialize
+    @value = 0
+    @lock = Mutex.new
+  end # def initialize
+
+  # Mark an event
+  def mark
+    @lock.synchronize do
+      @value += 1
+      # TODO(sissel): Keep some moving averages?
+    end
+  end # def mark
+
+  # Get the value of this metric.
+  public
+  def value
+    return @lock.synchronize { @value }
+  end # def value
+end # class Cabin::Metrics::Counter

data/lib/cabin/metrics/timer.rb

@@ -0,0 +1,63 @@
+require "cabin/namespace"
+require "thread"
+
+class Cabin::Metrics::Timer
+  # A new Timer metric 
+  #
+  # Timers behave like a combination of Meter and Histogram. Every Timer
+  # invocation is metered and the duration of the timer is put into the
+  # Histogram.
+  public
+  def initialize
+    @invocations = 0
+    @lock = Mutex.new
+  end # def initialize
+
+  # Start timing something.
+  #
+  # If no block is given
+  # If a block is given, the execution of that block is timed.
+  #
+  public
+  def time(&block)
+    return time_block(&block) if block_given?
+
+    # Return an object we can .stop
+    return TimerContext.new(method(:record))
+  end # def time
+
+  private
+  def time_block(&block)
+    start = Time.now
+    block.call
+    record(Time.now - start)
+  end # def time_block
+
+  public
+  def record(duration)
+    @lock.synchronize do
+      @invocations += 1
+      # TODO(sissel): histogram the duration
+    end
+  end # def record
+
+  # Get the number of times this timer has been used
+  public
+  def count
+    return @lock.synchronize { @invocations }
+  end # def value
+
+  class TimerContext
+    public
+    def initialize(&stop_callback)
+      @start = Time.now
+      @callback = stop_callback
+    end
+
+    public
+    def stop
+      duration = Time.now - @start
+      @callback.call(duration)
+    end # def stop
+  end # class TimerContext
+end # class Cabin::Metrics::Counter

data/lib/cabin/mixins/CAPSLOCK.rb

@@ -0,0 +1,24 @@
+require "cabin/namespace"
+
+# ALL CAPS MEANS SERIOUS BUSINESS
+module Cabin::Mixins::CAPSLOCK
+  def log(level, message, data={})
+    if message.is_a?(Hash)
+      data.merge!(message)
+    else
+      data[:message] = message
+    end
+
+    # CAPITALIZE ALL THE STRINGS
+    data.each do |key, value|
+      value.upcase! if value.respond_to?(:upcase!)
+    end
+
+    # Add extra debugging bits (file, line, method) if level is debug.
+    debugharder(caller.collect { |c| c.upcase }, data) if @level == :debug
+
+    data[:level] = level.upcase
+
+    publish(data)
+  end # def log
+end # module Cabin::Mixins::CAPSLOCK

data/lib/cabin/mixins/logger.rb

@@ -13,7 +13,11 @@ module Cabin::Mixins::Logger
   }
 
   def level=(value)
-    @level = value.to_sym
+    if value.respond_to?(:downcase)
+      @level = value.downcase.to_sym
+    else
+      @level = value.to_sym
+    end
   end # def level
 
   # Define the usual log methods: info, fatal, etc.

data/lib/cabin/namespace.rb

@@ -3,4 +3,5 @@ module Cabin
     module EM; end
   end
   module Mixins; end
+  class Metrics; end
 end

data/lib/cabin/outputs/stdlib-logger.rb

@@ -8,15 +8,17 @@ class Cabin::Outputs::StdlibLogger
   public
   def initialize(logger)
     @logger = logger
+    @logger.level = logger.class::DEBUG
   end # def initialize
 
   # Receive an event
   public
   def <<(data)
-    method = data[:level] || "info"
+    method = data[:level].downcase.to_sym || :info
 
     message = "#{data[:message]} #{data.to_json}"
 
+    #p [@logger.level, logger.class::DEBUG]
     # This will call @logger.info(data) or something similar.
     @logger.send(method, message)
   end # def <<

data/test/all.rb

@@ -0,0 +1,13 @@
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require "rubygems"
+require "minitest/autorun"
+require "simplecov"
+
+SimpleCov.start
+
+dir = File.dirname(File.expand_path(__FILE__))
+Dir.glob(File.join(dir, "**", "test_*.rb")).each do |path|
+  puts "Loading tests from #{path}"
+  require path
+end

data/test/test_metrics.rb

@@ -0,0 +1,54 @@
+$: << File.dirname(__FILE__)
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require "rubygems"
+require "minitest-patch"
+require "cabin"
+require "cabin/metrics"
+require "minitest/autorun" if __FILE__ == $0
+
+describe Cabin::Metrics do
+  before do
+    @metrics = Cabin::Metrics.new
+  end
+
+  #test "gauge" do
+    #gauge = @metrics.gauge(self) { 3 }
+    #assert_equal(3, gauge.value)
+    ## metrics.first == [identifier, Gauge]
+    #assert_equal(3, @metrics.first.last.value)
+  #end
+
+  test "counter" do
+    counter = @metrics.counter(self)
+    0.upto(30) do |i|
+      assert_equal(i, counter.value)
+      counter.incr
+    end
+    31.downto(0) do |i|
+      assert_equal(i, counter.value)
+      counter.decr
+    end
+  end
+
+  test "meter counter" do
+    meter = @metrics.meter(self)
+    30.times do |i|
+      assert_equal(i, meter.value)
+      meter.mark
+    end
+  end
+
+  test "meter time-based averages" # TODO(sissel): implement
+
+  test "timer counter" do
+    timer = @metrics.timer(self)
+    30.times do |i|
+      assert_equal(i, timer.count)
+      timer.time { true }
+    end
+  end
+
+  test "timer histogram" # TODO(sissel): implement
+  test "histogram" # TODO(sissel): implement
+end # describe Cabin::Channel do

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cabin
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: 21
+  prerelease: 
   segments: 
   - 0
+  - 2
   - 1
-  - 8
-  version: 0.1.8
+  version: 0.2.1
 platform: ruby
 authors: 
 - Jordan Sissel
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-13 00:00:00 -08:00
+date: 2012-02-05 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,12 +26,13 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
   type: :runtime
   version_requirements: *id001
-description: This is an experiment to try and make logging more flexible and more consumable. Plain text logs are bullshit, let's emit structured and contextual logs.
+description: This is an experiment to try and make logging more flexible and more consumable. Plain text logs are bullshit, let's emit structured and contextual logs. Metrics, too!
 email: 
 - jls@semicomplete.com
 executables: 
@@ -40,21 +42,28 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/cabin.rb
-- lib/cabin/outputs/em/stdlib-logger.rb
-- lib/cabin/outputs/stdlib-logger.rb
-- lib/cabin/channel.rb
-- lib/cabin/namespace.rb
-- lib/cabin/timer.rb
 - lib/cabin/context.rb
-- lib/cabin/mixins/dragons.rb
-- lib/cabin/mixins/metrics.rb
+- lib/cabin/timer.rb
+- lib/cabin/outputs/stdlib-logger.rb
+- lib/cabin/outputs/em/stdlib-logger.rb
 - lib/cabin/mixins/logger.rb
+- lib/cabin/mixins/dragons.rb
+- lib/cabin/mixins/CAPSLOCK.rb
+- lib/cabin/namespace.rb
+- lib/cabin/metrics/gauge.rb
+- lib/cabin/metrics/timer.rb
+- lib/cabin/metrics/meter.rb
+- lib/cabin/metrics/counter.rb
+- lib/cabin/metrics.rb
+- lib/cabin/channel.rb
+- lib/cabin.rb
 - examples/fibonacci-timing.rb
 - examples/sinatra-logging.rb
 - examples/sample.rb
-- test/minitest-patch.rb
 - test/test_logging.rb
+- test/minitest-patch.rb
+- test/test_metrics.rb
+- test/all.rb
 - LICENSE
 - CHANGELIST
 - bin/rubygems-cabin-test
@@ -73,6 +82,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -81,13 +91,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Experiments in structured and contextual logging

data/lib/cabin/mixins/metrics.rb

@@ -1,16 +0,0 @@
-require "cabin/namespace"
-
-# What kind of metrics do we want?
-# Per-call/transaction/request metrics like:
-#   - hit (count++ type metrics)
-#   - latencies/timings
-#
-# Per app or generally long-lifetime metrics like:
-#   - "uptime"
-#   - cpu usage
-#   - memory usage
-#   - count of active/in-flight actions/requests/calls/transactions
-#   - peer metrics (number of cluster members, etc)
-module Cabin::Mixins::Metrics
-
-end # module Cabin::Mixins::Metrics