leafy-rack 0.1.0

data/spec/admin_rack_spec.rb

@@ -0,0 +1,141 @@
+require_relative 'setup'
+
+require 'leafy/rack/admin'
+require 'yaml'
+require 'json'
+
+describe Leafy::Rack::Admin do
+
+  subject { Leafy::Rack::Admin }
+  
+  let( :expected_headers ) do
+    { 'Content-Type' => 'text/html' }
+  end
+
+  let( :metrics ) { Leafy::Metrics::Registry.new }
+
+  let( :health ) { Leafy::Health::Registry.new }
+
+  let( :health_report ) do
+    { 'version' => '3.0.0',
+      'gauges' => {},
+      'counters' => {},
+      'histograms' => {},
+      'meters' => {},
+      'timers' =>  {}
+    }
+  end
+
+  let( :result ){ [ 200, nil, [] ] }
+  let( :app ) do
+    Proc.new() { result }
+  end
+
+  it 'has response' do
+    status, headers, body = subject.response( "/path" )
+    expect( status ).to eq 200
+    expect( headers.to_yaml).to eq expected_headers.to_yaml
+    expect( body.join.count("\n" ) ).to eq 15
+    expect( body.join.gsub( '/path/' ).collect { |f| f }.size ).to eq 6
+  end
+
+  describe 'default path' do
+    subject { Leafy::Rack::Admin.new( app, metrics, health ) }
+
+    it 'passes request if not matches the given path' do
+      env = { 'PATH_INFO'=> '/something' }
+      expect( subject.call( env ) ).to eq result
+    end
+
+    it 'shows menu page on admin path' do
+      env = { 'PATH_INFO'=> '/admin' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join.count("\n" ) ).to eq 15
+    end
+
+    it 'pongs on ping path' do
+      env = { 'PATH_INFO'=> '/admin/ping' }
+      status, _, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( body.join ).to eq 'pong'
+    end
+
+    it 'thread dump on threads path' do
+      env = { 'PATH_INFO'=> '/admin/threads' }
+      status, _, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( body.join.count( "\n" ) ).to be > 100
+    end
+
+    it 'reports metrics on metrics path' do
+      env = { 'PATH_INFO'=> '/admin/metrics' }
+      status, _, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( body.join.count( "\n" ) ).to eq 0
+      body = JSON.parse(body.join)
+      expect( body.to_yaml ).to eq health_report.to_yaml
+    end
+
+    it 'reports health-checks on health path' do
+      env = { 'PATH_INFO'=> '/admin/health' }
+      status, _, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( body.join.count( "\n" ) ).to eq 0
+      body = JSON.parse(body.join)
+      expect( body.to_yaml ).to eq "--- {}\n"
+    end
+  end
+
+  describe 'custom path' do
+    subject { Leafy::Rack::Admin.new( app, metrics, health, '/custom' ) }
+
+    it 'passes request if not matches the given path' do
+      env = { 'PATH_INFO'=> '/something' }
+      expect( subject.call( env ) ).to eq result
+      env = { 'PATH_INFO'=> '/ping' }
+      expect( subject.call( env ) ).to eq result
+    end
+
+    it 'shows menu page on admin path' do
+      env = { 'PATH_INFO'=> '/custom' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join.count("\n" ) ).to eq 15
+    end
+
+    it 'pongs on ping path' do
+      env = { 'PATH_INFO'=> '/custom/ping' }
+      status, _, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( body.join ).to eq 'pong'
+    end
+
+    it 'thread dump on threads path' do
+      env = { 'PATH_INFO'=> '/custom/threads' }
+      status, _, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( body.join.count( "\n" ) ).to be > 100
+    end
+
+    it 'reports metrics on metrics path' do
+      env = { 'PATH_INFO'=> '/custom/metrics' }
+      status, _, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( body.join.count( "\n" ) ).to eq 0
+      body = JSON.parse(body.join)
+      expect( body.to_yaml ).to eq health_report.to_yaml
+    end
+
+    it 'reports health-checks on health path' do
+      env = { 'PATH_INFO'=> '/custom/health' }
+      status, _, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( body.join.count( "\n" ) ).to eq 0
+      body = JSON.parse(body.join)
+      expect( body.to_yaml ).to eq "--- {}\n"
+    end
+  end
+end

data/spec/basic_instrumented_spec.rb

@@ -0,0 +1,31 @@
+require_relative 'setup'
+
+require 'leafy/instrumented/basic_instrumented'
+
+describe Leafy::Instrumented::BasicInstrumented do
+
+  subject { Leafy::Instrumented::BasicInstrumented.new( registry, "name" ) }
+ 
+  let( :registry ) { Leafy::Metrics::Registry.new }
+
+  let( :app ) do
+    Proc.new() do
+      sleep 0.1
+      [ 200, nil, registry.metrics.counters.values.first.count ]
+    end
+  end
+
+  it 'collects metrics for a call' do
+    _, _, count = subject.call do
+      app.call
+    end
+    expect( count ).to eq 1
+    expect( registry.metrics.timers.keys ).to eq [ 'name.requests' ] 
+    expect( registry.metrics.timers.values.first.mean_rate ).to be > 0.9
+    expect( registry.metrics.counters.keys ).to eq [ 'name.active_requests' ] 
+    expect( registry.metrics.counters.values.collect { |a| a.count } ).to eq [ 0 ]
+    expect( registry.metrics.meters.keys ).to eq [ 'name.responseCodes.other' ] 
+    expect( registry.metrics.meters.values.collect { |a| a.count } ).to eq [ 1 ]
+    expect( registry.metrics.meters.values.first.mean_rate ).to be > 5.0
+  end
+end

data/spec/health_rack_spec.rb

@@ -0,0 +1,136 @@
+require_relative 'setup'
+
+require 'leafy/rack/health'
+require 'yaml'
+require 'json'
+
+describe Leafy::Rack::Health do
+
+  subject { Leafy::Rack::Health }
+
+  let( :registry ) { Leafy::Health::Registry.new }
+
+  let( :expected_headers ) do
+    { 'Content-Type' => 'application/json',
+      'Cache-Control' => 'must-revalidate,no-cache,no-store' }
+  end
+
+  let( :result ){ [ 200, nil, [] ] }
+  let( :app ) do
+    Proc.new() { result }
+  end
+
+  describe 'healthy' do
+
+    let( :health ) do
+      m = registry
+      m.register( 'two' ) do |ctx|
+        ctx.healthy 'ok'
+      end
+      m.health
+    end
+    let( :report ) do
+      { 'two' => { 'healthy' => true, 'message' => 'ok' } }
+    end
+
+    it 'has response' do
+      status, headers, body = subject.response( health, {} )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      body = JSON.parse( body.join )
+      expect( body.to_yaml ).to eq report.to_yaml
+    end
+
+    it 'has pretty response' do
+      status, headers, body = subject.response( health, { 'QUERY_STRING' => 'pretty' } )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join.count( "\n" ) ).to eq 5
+      body = JSON.parse( body.join )
+      expect( body.to_yaml ).to eq report.to_yaml
+    end
+  end
+
+  describe 'unhealthy' do
+    let( :health ) do
+      m = registry
+      m.register( 'one' ) do |ctx|
+        'error'
+      end
+      m.health
+    end
+
+    let( :report ) do
+      { 'one' => { 'healthy' => false, 'message' => 'error' } }
+    end
+
+    it 'has response' do
+      status, headers, body = subject.response( health, {} )
+      expect( status ).to eq 500
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      body = JSON.parse( body.join )
+      expect( body.to_yaml ).to eq report.to_yaml
+    end
+
+    it 'has pretty response' do
+      status, headers, body = subject.response( health, { 'QUERY_STRING' => 'pretty' } )
+      expect( status ).to eq 500
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join.count( "\n" ) ).to eq 5
+      body = JSON.parse( body.join )
+      expect( body.to_yaml ).to eq report.to_yaml
+    end
+  end
+
+  describe 'default path' do
+    subject { Leafy::Rack::Health.new( app, registry ) }
+
+    it 'passes request if not matches the given path' do
+      env = { 'PATH_INFO'=> '/something' }
+      expect( subject.call( env ) ).to eq result
+    end
+
+    it 'reports health-checks on health path' do
+      env = { 'PATH_INFO'=> '/health' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join ).to eq '{}'
+    end
+
+    it 'reports "pretty" health-checks on health path' do
+      env = { 'PATH_INFO'=> '/health', 'QUERY_STRING' => 'pretty' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join ).to eq '{ }'
+    end
+  end
+
+  describe 'custom path' do
+    subject { Leafy::Rack::Health.new( app, registry, '/custom' ) }
+
+    it 'passes request if not matches the given path' do
+      env = { 'PATH_INFO'=> '/something' }
+      expect( subject.call( env ) ).to eq result
+      env = { 'PATH_INFO'=> '/health' }
+      expect( subject.call( env ) ).to eq result
+    end
+
+    it 'reports health-checks on health path' do
+      env = { 'PATH_INFO'=> '/custom' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join ).to eq '{}'
+    end
+
+    it 'reports "pretty" health-checks on health path' do
+      env = { 'PATH_INFO'=> '/custom', 'QUERY_STRING' => 'pretty' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join ).to eq '{ }'
+    end
+  end
+end

data/spec/health_writer_spec.rb

@@ -0,0 +1,47 @@
+require_relative 'setup'
+
+require 'leafy/health'
+require 'leafy/json/health_writer'
+require 'yaml'
+require 'json'
+
+describe Leafy::Json::HealthWriter do
+
+  subject { Leafy::Json::HealthWriter.new }
+
+  let( :health ) do
+    m = Leafy::Health::Registry.new
+    m.register( 'one' ) do
+      'error'
+    end
+    m.register( 'two' ) do |ctx|
+      ctx.healthy 'ok'
+    end
+    m.register( 'three' ) do |ctx|
+      ctx.unhealthy 'no ok'
+    end
+    m.health
+  end
+
+  let( :expected ) do
+    {
+      "one"=> {"healthy"=>false, "message"=>"error"},
+      "three"=>{"healthy"=>false, "message"=>"no ok"},
+      "two"=>{"healthy"=>true, "message"=>"ok"}
+    }
+  end
+
+  it 'serializes health-check data to json' do
+    data = subject.to_json( health.run_health_checks )
+    expect( data.count( "\n" ) ).to eq 0
+    data = JSON.parse( data )
+    expect( data.to_yaml ).to eq expected.to_yaml
+  end
+
+  it 'serializes health-check data to json (pretty print)' do
+    data = subject.to_json( health.run_health_checks, true )
+    expect( data.count( "\n" ) ).to eq 13
+    data = JSON.parse( data )
+    expect( data.to_yaml ).to eq expected.to_yaml
+  end
+end

data/spec/instrumented_rack_spec.rb

@@ -0,0 +1,37 @@
+require_relative 'setup'
+
+require 'leafy/rack/instrumented'
+
+describe Leafy::Rack::Instrumented do
+
+  subject { Leafy::Rack::Instrumented.new( app, instrumented ) }
+ 
+  let( :instrumented ) { Leafy::Instrumented::Instrumented.new( registry, "name" ) }
+ 
+  let( :registry ) { Leafy::Metrics::Registry.new }
+
+  let( :status ) { (Random.rand * 500 + 100).to_i }
+    
+  let( :random ) { Random.rand.to_s }
+    
+  let( :app ) do
+    Proc.new do
+      [ status, {}, [ random ] ]
+    end
+  end
+
+  it "collects metrics for a call and pass result on" do
+    result, _, body = subject.call( {} )
+    expect( result ).to eq status
+    expect( body.join ).to eq random
+
+    expect( registry.metrics.timers.keys ).to eq [ 'name.requests' ] 
+    expect( registry.metrics.timers.values.first.mean_rate ).to be > 0.09
+
+    expect( registry.metrics.counters.keys ).to eq [ 'name.active_requests' ] 
+    expect( registry.metrics.counters.values.collect { |a| a.count } ).to eq [ 0 ]
+
+    expect( registry.metrics.meters.values.select{ |a| a.count == 0 }.size ).to eq 7
+    expect( registry.metrics.meters.values.select{ |a| a.count == 1 }.size ).to eq 1
+  end
+end

data/spec/instrumented_spec.rb

@@ -0,0 +1,36 @@
+require_relative 'setup'
+
+require 'leafy/instrumented/instrumented'
+
+describe Leafy::Instrumented::Instrumented do
+
+  subject { Leafy::Instrumented::Instrumented.new( registry, "name" ) }
+ 
+  let( :registry ) { Leafy::Metrics::Registry.new }
+
+  [ 400, 201, 204, 404, 200, 123, 205, 500 ].each_with_index do |status, index|
+    it "collects metrics for a call for status #{status}" do
+      result, _, _ = subject.call do
+        sleep 0.01
+        [ status, nil, nil ]
+      end
+
+      expect( result ).to eq status
+
+      expect( registry.metrics.timers.keys ).to eq [ 'name.requests' ] 
+      expect( registry.metrics.timers.values.first.mean_rate ).to be > 0.09
+
+      expect( registry.metrics.counters.keys ).to eq [ 'name.active_requests' ] 
+      expect( registry.metrics.counters.values.collect { |a| a.count } ).to eq [ 0 ]
+      
+      expect( registry.metrics.meters.keys.sort ).to eq [ 'name.responseCodes.badRequest', 'name.responseCodes.created', 'name.responseCodes.noContent', 'name.responseCodes.notFound', 'name.responseCodes.ok', 'name.responseCodes.other', 'name.responseCodes.resetContent', 'name.responseCodes.serverError' ]
+
+      stati = registry.metrics.meters.values.collect { |a| a.count }
+      expect( stati[ index ] ).to eq 1
+      stati.delete 1
+      expect( stati ).to eq [0,0,0,0,0,0,0]
+
+      expect( registry.metrics.meters.values.to_a[ index ].mean_rate ).to be > 50
+    end
+  end
+end

data/spec/metrics_rack_spec.rb

@@ -0,0 +1,110 @@
+require_relative 'setup'
+
+require 'leafy/rack/metrics'
+require 'yaml'
+require 'json'
+
+describe Leafy::Rack::Metrics do
+
+  subject { Leafy::Rack::Metrics }
+
+  let( :registry ) { Leafy::Metrics::Registry.new }
+
+  let( :expected_headers ) do
+    { 'Content-Type' => 'application/json',
+      'Cache-Control' => 'must-revalidate,no-cache,no-store' }
+  end
+  let( :report ) do
+    { 'version' => '3.0.0',
+      'gauges' => {},
+      'counters' => {},
+      'histograms' => {},
+      'meters' => {},
+      'timers' =>  {}
+    }
+  end
+
+  let( :result ){ [ 200, nil, [] ] }
+  let( :app ) do
+    Proc.new() { result }
+  end
+
+  it 'has response' do
+    status, headers, body = subject.response( registry.metrics, {} )
+    expect( status ).to eq 200
+    expect( headers.to_yaml).to eq expected_headers.to_yaml
+    expect( body.join.count( "\n" ) ).to eq 0
+    body = JSON.parse( body.join )
+    expect( body.to_yaml ).to eq report.to_yaml
+  end
+
+  it 'has pretty response' do
+    status, headers, body = subject.response( registry.metrics,
+                                              { 'QUERY_STRING' => 'pretty' } )
+    expect( status ).to eq 200
+    expect( headers.to_yaml).to eq expected_headers.to_yaml
+    expect( body.join.count( "\n" ) ).to eq 7
+    body = JSON.parse( body.join )
+    expect( body.to_yaml ).to eq report.to_yaml
+  end
+
+  describe 'default path' do
+    subject { Leafy::Rack::Metrics.new( app, registry ) }
+
+    it 'passes request if not matches the given path' do
+      env = { 'PATH_INFO'=> '/something' }
+      expect( subject.call( env ) ).to eq result
+    end
+
+    it 'reports metricss on metrics path' do
+      env = { 'PATH_INFO'=> '/metrics' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join.count( "\n" ) ).to eq 0
+      body = JSON.parse(body.join)
+      expect( body.to_yaml ).to eq report.to_yaml
+    end
+
+    it 'reports "pretty" health-checks on health path' do
+      env = { 'PATH_INFO'=> '/metrics', 'QUERY_STRING' => 'pretty' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join.count( "\n" ) ).to eq 7
+      body = JSON.parse(body.join)
+      expect( body.to_yaml ).to eq report.to_yaml
+    end
+  end
+
+  describe 'custom path' do
+    subject { Leafy::Rack::Metrics.new( app, registry, '/custom' ) }
+
+    it 'passes request if not matches the given path' do
+      env = { 'PATH_INFO'=> '/something' }
+      expect( subject.call( env ) ).to eq result
+      env = { 'PATH_INFO'=> '/metrics' }
+      expect( subject.call( env ) ).to eq result
+    end
+
+    it 'reports metricss on metrics path' do
+      env = { 'PATH_INFO'=> '/custom' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join.count( "\n" ) ).to eq 0
+      body = JSON.parse(body.join)
+      expect( body.to_yaml ).to eq report.to_yaml
+    end
+
+    it 'reports "pretty" health-checks on health path' do
+      env = { 'PATH_INFO'=> '/custom', 'QUERY_STRING' => 'pretty' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body.join.count( "\n" ) ).to eq 7
+      body = JSON.parse(body.join)
+      expect( body.to_yaml ).to eq report.to_yaml
+    end
+  end
+end

data/spec/metrics_writer_spec.rb

@@ -0,0 +1,55 @@
+require_relative 'setup'
+
+require 'leafy/metrics'
+require 'leafy/json/metrics_writer'
+require 'yaml'
+require 'json'
+
+describe Leafy::Json::MetricsWriter do
+
+  subject { Leafy::Json::MetricsWriter.new }
+
+  let( :metrics ) do
+    m = Leafy::Metrics::Registry.new
+    m.register_meter( 'one' ).mark
+    m.register_meter( 'two' ).mark
+    c = m.register_counter( 'three' )
+    c.inc
+    c.inc
+    m.metrics
+  end
+
+  let( :expected ) do
+    {
+      "two"=> {"count"=>1,
+        "m15_rate"=>0.0,
+        "m1_rate"=>0.0,
+        "m5_rate"=>0.0,
+        "units"=>"events/second"}, 
+      "one"=> {"count"=>1, 
+        "m15_rate"=>0.0, 
+        "m1_rate"=>0.0, 
+        "m5_rate"=>0.0, 
+        "units"=>"events/second"}, 
+      "three"=>{"count"=>2}
+    }
+  end
+
+  it 'serializes metrics data to json' do
+    data = subject.to_json( metrics.metrics )
+    expect( data.count( "\n" ) ).to eq 0
+    data = JSON.parse( data )
+    expect( data['one'].delete('mean_rate') ).to be >0
+    expect( data['two'].delete('mean_rate') ).to be >0
+    expect( data.to_yaml ).to eq expected.to_yaml
+  end
+
+  it 'serializes metrics data to json (pretty print)' do
+    data = subject.to_json( metrics.metrics, true )
+    expect( data.count( "\n" ) ).to eq 20
+    data = JSON.parse( data )
+    expect( data['one'].delete('mean_rate') ).to be >0
+    expect( data['two'].delete('mean_rate') ).to be >0
+    expect( data.to_yaml ).to eq expected.to_yaml
+  end
+end

data/spec/ping_rack_spec.rb

@@ -0,0 +1,63 @@
+require_relative 'setup'
+
+require 'leafy/rack/ping'
+require 'yaml'
+require 'json'
+
+describe Leafy::Rack::Ping do
+
+  subject { Leafy::Rack::Ping }
+  
+  let( :expected_headers ) do
+    { 'Content-Type' => 'text/plain',
+      'Cache-Control' => 'must-revalidate,no-cache,no-store' }
+  end
+
+  let( :result ){ [ 200, nil, [] ] }
+  let( :app ) do
+    Proc.new() { result }
+  end
+
+  it 'has response' do
+    status, headers, body = subject.response
+    expect( status ).to eq 200
+    expect( headers.to_yaml).to eq expected_headers.to_yaml
+    expect( body ).to eq ['pong']
+  end
+
+  describe 'default path' do
+    subject { Leafy::Rack::Ping.new( app ) }
+
+    it 'passes request if not matches the given path' do
+      env = { 'PATH_INFO'=> '/something' }
+      expect( subject.call( env ) ).to eq result
+    end
+
+    it 'pongs on ping path' do
+      env = { 'PATH_INFO'=> '/ping' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body ).to eq ['pong']
+    end
+  end
+
+  describe 'custom path' do
+    subject { Leafy::Rack::Ping.new( app, '/custom' ) }
+
+    it 'passes request if not matches the given path' do
+      env = { 'PATH_INFO'=> '/something' }
+      expect( subject.call( env ) ).to eq result
+      env = { 'PATH_INFO'=> '/ping' }
+      expect( subject.call( env ) ).to eq result
+    end
+
+    it 'pongs on ping path' do
+      env = { 'PATH_INFO'=> '/custom' }
+      status, headers, body = subject.call( env )
+      expect( status ).to eq 200
+      expect( headers.to_yaml).to eq expected_headers.to_yaml
+      expect( body ).to eq ['pong']
+    end
+  end
+end

data/spec/setup.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.expand_path( '../../lib', __FILE__ )
+$LOAD_PATH.unshift File.expand_path( '../../../leafy-health/lib', __FILE__ )
+$LOAD_PATH.unshift File.expand_path( '../../../leafy-metrics/lib', __FILE__ )