sinatra-health-check 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 334bafa6e4d41f6204c4b8dd3c85c9ae0bcd7197
-  data.tar.gz: 177f9eb36abcbc83d387f6cf2893d60853bc45e4
+  metadata.gz: 629086796b22da38bdfb0bb9424c6a948139c4f8
+  data.tar.gz: 46c9a99be29204445dedd53de8cd3a57f6093c6e
 SHA512:
-  metadata.gz: 31e2492861672eb3e93bd0ebfce9ec1ae0c635d74dca19c9b10a85ccb8064cc14eef85aaf6ee57312e91912a5fc99120db96aa8c023f455f131e06b888ef5c93
-  data.tar.gz: 2cc30092da95700d7c10710b0594c97257c162518a0a9030ec364364b7c0466f842746870d3fd5119681615158d4006b051694e8f5423231b3065b36eadd5f4b
+  metadata.gz: 3a017a22ffb6da52096e0c35ff275f128407c47aaa17e4c06c82033da6a65d6641b6b14189e75882f2e10f9951cec0fe7e3e541a99e74b736c4e661d8b9c7f96
+  data.tar.gz: 1d6db01bbd831a451492957f5e978a977b6cc6b8a672329285d06460f4af2818f23adb18a531087af9d70db1cb7f01e4633a9b7979cc9a91b0e120b24d8833b4

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Otto (GmbH & Co KG)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/lib/sinatra-health-check.rb

@@ -1,4 +1,9 @@
 module SinatraHealthCheck
   require_relative 'sinatra-health-check/version'
+  require_relative 'sinatra-health-check/status'
+  require_relative 'sinatra-health-check/status/aggregated'
+  require_relative 'sinatra-health-check/status/overwriting_aggregator'
+  require_relative 'sinatra-health-check/status/forgiving_aggregator'
+  require_relative 'sinatra-health-check/status/strict_aggregator'
   require_relative 'sinatra-health-check/checker'
 end

data/lib/sinatra-health-check/checker.rb

@@ -3,29 +3,36 @@
 class SinatraHealthCheck::Checker
 
   DEFAULT_OPTS = {
-    :exit    => true,
-    :health  => true,
-    :logger  => nil,
-    :signals => %w[TERM INT],
-    :timeout => 10,
-    :wait    => 0,
+    :aggregator => SinatraHealthCheck::Status::StrictAggregator.new,
+    :exit       => true,
+    :health     => true,
+    :logger     => nil,
+    :signals    => %w[TERM INT],
+    :systems    => {},
+    :timeout    => 10,
+    :wait       => 0,
   }
 
   require 'thread'
 
   attr_accessor :health
-  alias :healthy? :health
+  attr_reader :systems
 
   # Create a health checker.
   # Params:
+  # ++aggrgator++: an aggregator for substatuus, default: StrictAggregator
   # ++exit++: call ++exit++ at the end of ++graceful_stop++
   # ++health++: initial health state
   # ++logger++: a logger
   # ++signals++: array of signals to register a graceful stop handler
+  # ++systems++: a hash of subsystems responding to .status
   # ++timeout++: timeout for graceful stop in seconds
-  def initialize(opts = DEFAULT_OPTS)
+  # ++wait++: wait before setting health to unhealthy
+  def initialize(opts = {})
     @opts = DEFAULT_OPTS.merge(opts)
+    @aggregator = SinatraHealthCheck::Status::OverwritingAggregator.new(@opts[:aggregator])
     @health = @opts[:health]
+    @systems = @opts[:systems]
     trap(@opts[:signals])
   end
 
@@ -53,6 +60,17 @@ class SinatraHealthCheck::Checker
     @stopper.join if @stopper
   end
 
+  # Returns a Status object
+  def status
+    statuus = {}
+    systems.each { |k,v| statuus[k] = v.status if v.respond_to?(:status) }
+    @aggregator.aggregate(statuus, health ? nil : SinatraHealthCheck::Status.new(:error, 'app is unhealthy'))
+  end
+
+  def healthy?
+    status.level != :error
+  end
+
   private
 
   def logger

data/lib/sinatra-health-check/status.rb

@@ -0,0 +1,37 @@
+# Application status definition
+class SinatraHealthCheck::Status
+
+  SEVERITIES = {
+    :ok      => 0,
+    :warning => 1,
+    :error   => 2,
+  }
+
+  attr_reader :level, :message, :extras
+
+  def initialize(level, message, extras = {})
+    raise ArgumentError, "level must be one of #{SEVERITIES.keys.join(', ')}, but is #{level}" unless SEVERITIES[level]
+    raise ArgumentError, "message must not be nil" unless message
+    raise ArgumentError, "extras must be a hash, but is #{extras.class}" unless extras.is_a?(Hash)
+
+    @level = level
+    @message = message
+    @extras = extras
+  end
+
+  def to_i
+    SEVERITIES[level]
+  end
+  alias :severity :to_i
+
+  def to_h
+    {
+      :status  => level.to_s.upcase,
+      :message => message,
+    }.merge(extras)
+  end
+
+  def to_json
+    to_h.to_json
+  end
+end

data/lib/sinatra-health-check/status/aggregated.rb

@@ -0,0 +1,24 @@
+# Application status definition with subsystems
+class SinatraHealthCheck::Status::Aggregated < SinatraHealthCheck::Status
+
+  attr_reader :statuus
+
+  def initialize(level, message, statuus, extras = {})
+    raise ArgumentError, "statuus must be a hash of SinatraHealthCheck::Status, but is #{statuus.class}" \
+      unless statuus.is_a?(Hash)
+    super(level, message, { :statusDetails => statuus }.merge(extras))
+  end
+
+  def to_h
+    subs = {}
+    extras[:statusDetails].each { |k,v| subs[k] = v.to_h }
+
+    s = extras.merge({
+      :status  => level.to_s.upcase,
+      :message => message,
+      :statusDetails => subs
+    })
+    s.delete(:statusDetails) if s[:statusDetails].size == 0
+    s
+  end
+end

data/lib/sinatra-health-check/status/forgiving_aggregator.rb

@@ -0,0 +1,9 @@
+# Aggregate sub statuus, best wins
+class SinatraHealthCheck::Status::ForgivingAggregator
+  def aggregate(statuus)
+    status = statuus.values.min_by { |s| s.to_i } || SinatraHealthCheck::Status.new(:ok, 'everything is fine')
+    message = status.level == :ok ? 'everything is fine' : "all statuus are at least #{status.level}"
+
+    SinatraHealthCheck::Status::Aggregated.new(status.level, message, statuus)
+  end
+end

data/lib/sinatra-health-check/status/overwriting_aggregator.rb

@@ -0,0 +1,16 @@
+# Aggregate statuus with an aggregator but allow overwriting :level and :message.
+class SinatraHealthCheck::Status::OverwritingAggregator
+  def initialize(aggregator)
+    raise ArgumentError, 'aggregator must respond to .aggregate' unless aggregator.respond_to?(:aggregate)
+    @aggregator = aggregator
+  end
+
+  # aggregate statuus with given aggregator, but overwrite :status and :message if overwrite is given too
+  def aggregate(statuus, overwrite = nil)
+    if overwrite
+      SinatraHealthCheck::Status::Aggregated.new(overwrite.level, overwrite.message, statuus)
+    else
+      @aggregator.aggregate(statuus)
+    end
+  end
+end

data/lib/sinatra-health-check/status/strict_aggregator.rb

@@ -0,0 +1,9 @@
+# Aggregate sub statuus, worst wins
+class SinatraHealthCheck::Status::StrictAggregator
+  def aggregate(statuus)
+    status = statuus.values.max_by { |s| s.to_i } || SinatraHealthCheck::Status.new(:ok, 'everything is fine')
+    message = status.level == :ok ? 'everything is fine' : "at least one status is #{status.level}"
+
+    SinatraHealthCheck::Status::Aggregated.new(status.level, message, statuus)
+  end
+end

data/lib/sinatra-health-check/version.rb

@@ -1,3 +1,3 @@
 module SinatraHealthCheck
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/sinatra-health-check/checker_spec.rb

@@ -56,4 +56,29 @@ describe SinatraHealthCheck::Checker do
     end
   end
 
+  context '#status' do
+    it 'has a status' do
+      expect(subject.status.level).to eq(:ok)
+      expect(subject.healthy?).to be_truthy
+      expect(subject.status.to_h[:statusDetails]).to be_nil
+    end
+
+    it 'has substatus' do
+      substatus = SinatraHealthCheck::Status.new(:ok, 'sub is ok')
+      system = double("System", :status => substatus)
+      subject.systems[:sub] = system
+      expect(subject.status.level).to eq(:ok)
+      expect(subject.healthy?).to be_truthy
+      expect(subject.status.to_h[:statusDetails][:sub]).to eq(substatus.to_h)
+    end
+
+    it 'is unhealthy with unhealthy subsystem' do
+      substatus = SinatraHealthCheck::Status.new(:error, 'unhealthy')
+      system = double("System", :status => substatus)
+      subject.systems[:sub] = system
+      expect(subject.status.level).to eq(:error)
+      expect(subject.healthy?).to be_falsey
+    end
+  end
+
 end

data/spec/sinatra-health-check/forgiving_aggregator_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe SinatraHealthCheck::Status::ForgivingAggregator do
+
+  context '#aggregate' do
+
+    ONE = SinatraHealthCheck::Status.new(:error, 'foo')
+    TWO = SinatraHealthCheck::Status.new(:warning, 'bar')
+    THREE = SinatraHealthCheck::Status.new(:ok, 'foobar')
+
+    it 'aggregates {} to :ok' do
+      expect(subject.aggregate({}).level).to eq(:ok)
+    end
+
+    it 'aggregates to :ok when one status is :ok' do
+      statuus = {
+        :one => ONE,
+        :two => TWO,
+        :three => THREE,
+      }
+      expect(subject.aggregate(statuus).level).to eq(:ok)
+    end
+
+    it 'aggregates to :warning when one status is :warning' do
+      statuus = {
+        :one => ONE,
+        :two => TWO,
+      }
+      expect(subject.aggregate(statuus).level).to eq(:warning)
+    end
+
+    it 'aggregates to :error when all status are :error' do
+      statuus = {
+        :one => ONE,
+      }
+      expect(subject.aggregate(statuus).level).to eq(:error)
+    end
+
+    it 'aggregates details' do
+      statuus = {
+        :one => ONE,
+        :two => TWO,
+      }
+      expect(subject.aggregate(statuus).to_h[:statusDetails]).to eq({
+        :one => {
+          :status => 'ERROR',
+          :message => 'foo',
+        },
+        :two => {
+          :status => 'WARNING',
+          :message => 'bar',
+        },
+      })
+    end
+  end
+
+end

data/spec/sinatra-health-check/overwriting_aggregator_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe SinatraHealthCheck::Status::OverwritingAggregator do
+
+  context '#aggregate' do
+    aggregator = SinatraHealthCheck::Status::ForgivingAggregator.new
+    subject { described_class.new(aggregator) }
+
+    it 'overwrites the status' do
+      expect(aggregator).not_to receive(:aggregate)
+      expect(subject.aggregate({}, SinatraHealthCheck::Status.new(:error, 'foo')).level).to eq(:error)
+    end
+
+    it 'does not overwrite the status' do
+      expect(aggregator).to receive(:aggregate) { :foo }
+      expect(subject.aggregate({})).to eq(:foo)
+    end
+  end
+
+end

data/spec/sinatra-health-check/status_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe SinatraHealthCheck::Status do
+
+  describe '#init' do
+    subject { described_class.new(:ok, 'fooo')}
+    its(:level) { should == :ok }
+    its(:message) { should == 'fooo' }
+    its(:to_i) { should == 0 }
+    its(:to_h) { should == { :status => 'OK', :message => 'fooo' } }
+    its(:to_json) { should == { :status => 'OK', :message => 'fooo' }.to_json }
+  end
+
+end

data/spec/sinatra-health-check/strict_aggregator_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe SinatraHealthCheck::Status::StrictAggregator do
+
+  context '#aggregate' do
+
+    ONE = SinatraHealthCheck::Status.new(:error, 'foo')
+    TWO = SinatraHealthCheck::Status.new(:warning, 'bar')
+    THREE = SinatraHealthCheck::Status.new(:ok, 'foobar')
+
+    it 'aggregates {} to :ok' do
+      expect(subject.aggregate({}).level).to eq(:ok)
+    end
+
+    it 'aggregates to :ok when one status is :ok' do
+      statuus = {
+        :one => ONE,
+        :two => TWO,
+        :three => THREE,
+      }
+      expect(subject.aggregate(statuus).level).to eq(:error)
+    end
+
+    it 'aggregates to :warning when one status is :warning' do
+      statuus = {
+        :two => TWO,
+        :three => THREE,
+      }
+      expect(subject.aggregate(statuus).level).to eq(:warning)
+    end
+
+    it 'aggregates to :error when all status are :error' do
+      statuus = {
+        :three => THREE,
+      }
+      expect(subject.aggregate(statuus).level).to eq(:ok)
+    end
+
+    it 'aggregates details' do
+      statuus = {
+        :one => ONE,
+        :two => TWO,
+      }
+      expect(subject.aggregate(statuus).to_h[:statusDetails]).to eq({
+        :one => {
+          :status => 'ERROR',
+          :message => 'foo',
+        },
+        :two => {
+          :status => 'WARNING',
+          :message => 'bar',
+        },
+      })
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-health-check
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Felix Bechstein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-15 00:00:00.000000000 Z
+date: 2015-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -120,13 +120,23 @@ files:
 - ".simplecov"
 - ".travis.yml"
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - lib/sinatra-health-check.rb
 - lib/sinatra-health-check/checker.rb
+- lib/sinatra-health-check/status.rb
+- lib/sinatra-health-check/status/aggregated.rb
+- lib/sinatra-health-check/status/forgiving_aggregator.rb
+- lib/sinatra-health-check/status/overwriting_aggregator.rb
+- lib/sinatra-health-check/status/strict_aggregator.rb
 - lib/sinatra-health-check/version.rb
 - sinatra-health-check.gemspec
 - spec/sinatra-health-check/checker_spec.rb
+- spec/sinatra-health-check/forgiving_aggregator_spec.rb
+- spec/sinatra-health-check/overwriting_aggregator_spec.rb
+- spec/sinatra-health-check/status_spec.rb
+- spec/sinatra-health-check/strict_aggregator_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/otto-de/sinatra-health-check
 licenses:
@@ -154,4 +164,8 @@ specification_version: 4
 summary: This health check adds graceful stop to your sinatra applications
 test_files:
 - spec/sinatra-health-check/checker_spec.rb
+- spec/sinatra-health-check/forgiving_aggregator_spec.rb
+- spec/sinatra-health-check/overwriting_aggregator_spec.rb
+- spec/sinatra-health-check/status_spec.rb
+- spec/sinatra-health-check/strict_aggregator_spec.rb
 - spec/spec_helper.rb