leafy-rack 0.4.0-java

data/spec/collected_instrumented_spec.rb

@@ -0,0 +1,32 @@
+require_relative 'setup'
+
+require 'leafy/instrumented/collected_instrumented'
+
+describe Leafy::Instrumented::CollectedInstrumented do
+
+  subject { Leafy::Instrumented::CollectedInstrumented.new( registry, "name" ) }
+ 
+  let( :registry ) { Leafy::Metrics::Registry.new }
+
+  [ 201, 304, 404, 503, 123 ].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.meters.keys.sort ).to eq [ "name.responseCodes.2xx", "name.responseCodes.3xx", "name.responseCodes.4xx", "name.responseCodes.5xx", "name.responseCodes.other" ]
+
+      stati = registry.metrics.meters.values.collect { |a| a.count }
+      expect( stati[ index ] ).to eq 1
+
+      expected = [0,0,0,0,0]
+      expected[ index ] = 1
+      expect( stati ).to eq expected
+
+      expect( registry.metrics.meters.values.to_a[ index ].mean_rate ).to be > 50
+    end
+  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 503
+      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 503
+      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.gsub( /\s/m, '' ) ).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.gsub( /\s/m, '' ) ).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,56 @@
+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 }
+
+  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 ]
+  end
+
+  [ 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
+
+      expected = [0,0,0,0,0,0,0,0]
+      expected[ index ] = 1
+      expect( stati ).to eq expected
+
+      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