wellness 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be689a6ab96381d2df5fd2b0d54364b69a39b13b
-  data.tar.gz: 1fd60250f3cf1078e12b980ce15e5b087e74b5c1
+  metadata.gz: 83d31bae5ada6170c0a1c9349df2e637c5cb2acf
+  data.tar.gz: 7e3d8a4b30dced90941b21c3c5c246e1e44c4a9a
 SHA512:
-  metadata.gz: b1912e752de710339207d1690789a7d68d4efdb2080a3cae3601d69c306faba555ffb3bcc66c515998f9d75db901aff796707de7f383138cde87a65ed5c2afae
-  data.tar.gz: 6099437bde358740b504951620a8ac2de008ec0d23b2e6e91b8edd425724beb129a88c560eb66e4081a8efc1427b41fc7b9ad597054380e3d81cd4caf6287260
+  metadata.gz: 2fb50394b50629a867c2cf8c1e4744850cfc4872bbb68944b9ba612711de715a3a0117c78b50f9decc0f0c137e2db2151bc09b6be5de4adb2306a873e34c1eae
+  data.tar.gz: 558bb60650dc8653edf5fd9eba21e122c4e1b271db52e0fc1ee8bb6eb8c11d7f2a588e2ab5c817c8748a5d5db3ad8689f02aa56e16ba7e30c615daba26adfc34

data/.ruby-version

@@ -1 +1 @@
-2.0.0-p353
+2.1.2

data/.travis.yml

@@ -1,6 +1,7 @@
 language: ruby
 rvm:
+ - 2.1.2
+ - 2.1.1
  - 2.0.0
- - 1.9.3
 notifications:
   irc: "chat.freenode.net#warmwaffles"

data/README.md

@@ -14,22 +14,26 @@ However, you must require them when you need them. This is because they have
 external dependencies that need to be loaded, that your application may not
 necessarily have.
 
-```rb
-# Within the configuration block
-
-system = Wellness::System.new('my-uber-duber-app')
-system.use(Wellness::Services::PostgresService, 'database', {
-  host:     ENV['POSTGRESQL_HOST'],
-  port:     ENV['POSTGRESQL_PORT'],
-  database: ENV['POSTGRESQL_DATABASE'],
-  user:     ENV['POSTGRESQL_USERNAME'],
-  password: ENV['POSTGRESQL_PASSWORD']
-})
-system.use(Wellness::Services::RedisService, 'redis', {
-  host: ENV['REDIS_HOST']
-})
-
-config.middleware.insert_before('::ActiveRecord::QueryCache', 'Wellness::Middleware', system)
+```ruby
+module MySuperCoolApplication
+  class Application < Rails::Application
+    system  = Wellness::System.new('my-super-cool-app')
+    service = Wellness::Services::PostgresService.new({
+      host:     ENV['POSTGRESQL_HOST'],
+      port:     ENV['POSTGRESQL_PORT'],
+      database: ENV['POSTGRESQL_DATABASE'],
+      user:     ENV['POSTGRESQL_USERNAME'],
+      password: ENV['POSTGRESQL_PASSWORD']
+    })
+    system.add_service('database', service, { critical: true })
+    service = Wellness::Services::RedisService.new({
+      host: ENV['REDIS_HOST']
+    })
+    system.add_service('redis', service, { critical: false})
+
+    config.middleware.insert_before('::ActiveRecord::QueryCache', 'Wellness::Middleware', system)
+  end
+end
 ```
 
 ## Usage - Sinatra
@@ -37,28 +41,32 @@ config.middleware.insert_before('::ActiveRecord::QueryCache', 'Wellness::Middlew
 ```ruby
 require 'wellness'
 
-system = Wellness::System.new('my-uber-duber-app')
-system.use(Wellness::Services::PostgresService, 'database', {
+system  = Wellness::System.new('my-super-cool-app')
+service = Wellness::Services::PostgresService.new({
   host:     ENV['POSTGRESQL_HOST'],
   port:     ENV['POSTGRESQL_PORT'],
   database: ENV['POSTGRESQL_DATABASE'],
   user:     ENV['POSTGRESQL_USERNAME'],
   password: ENV['POSTGRESQL_PASSWORD']
 })
-system.use(Wellness::Services::RedisService, 'redis', {
+system.add_service('database', service, { critical: true })
+service = Wellness::Services::RedisService.new({
   host: ENV['REDIS_HOST']
 })
+system.add_service('redis', service, { critical: false})
 
 use(Wellness::Middleware, system)
 ```
 
-## Example Response
+## Example Responses
 
 ```json
 {
-  "status":"UNHEALTHY",
-  "details":{
-
+  "status": "UNHEALTHY",
+  "details": {
+    "git" : {
+      "revision" : "1234567"
+    }
   },
   "dependencies":{
     "database":{
@@ -89,58 +97,118 @@ use(Wellness::Middleware, system)
 }
 ```
 
+```json
+{
+    "status": "HEALTHY",
+    "services": {
+        "postgresql": {
+            "status": "HEALTHY",
+            "details": { }
+        },
+        "mysql": {
+            "status": "HEALTHY",
+            "details": { }
+        }
+    },
+    "details": {
+        "git": {
+            "revision": "1234567"
+        }
+    }
+}
+```
+
 ## Custom Services
 
-Creating custom services is really easy. Always extend
-`Wellness::Services::Base`.
+Creating a custom service is super easy. As long as the service responds to
+`#call`, you are just fine. Passing a `lambda` or `Proc` is perfectly
+acceptable.
 
-Once that is done, you must implement the `#check` method.
+### Requirements
 
-The parameters passed into the service at creation are stored under `#params`.
-Under no circumstances, should you ever modify the original parameters list at
-run time. It can lead to unintended consequences, and weird bugs.
+This interface has a few requirements.
+
+  1. A service **MUST** respond to `#call`
+  2. A hash **MUST** be returned
+  3. The hash returned **MUST** contain a `status` key at the root level.
+  4. Status can **ONLY** be `HEALTHY`, `UNHEALTHY`, and `DEGRADED`
+  5. All hash keys **MUST** be strings
+
+### Example
 
 ```ruby
-# Your custom service
-class MyCustomService < Wellness::Services::Base
-  def check
-    if params[:foo]
+module MyServices
+  class MySQLService
+    def initialize(args={})
+      @connection_options = {
+        host: args[:host],
+        port: args[:port],
+        database: args[:database],
+        username: args[:username],
+        password: args[:password]
+      }
+    end
+
+    def healthy(details={})
       {
-        'status': 'HEALTHY'
+        'status' => 'HEALTHY',
+        'details' => details
       }
-    else
+    end
+
+    def unhealthy(details={})
       {
-        'status': 'UNHEALTHY'
+        'status' => 'UNHEALTHY',
+        'details' => details
       }
     end
+
+    def call
+      connection = Mysql2::Client.new(@connection_options)
+      connection.ping ? healthy : unhealthy
+    rescue Mysql2::Error => error
+      unhealthy('error' => error.message)
+    end
   end
 end
 
-# Initialize the wellness system
 system = Wellness::System.new('my-app')
-system.use(MyCustomService, 'some service', {foo: 'bar'})
-
-# Load it into your rack
-use(Wellness::Middleware, system)
+system.use('mysql', MyServices::MySQLService.new({
+  # ... configuration ...
+}))
 ```
 
 ## Custom Details
 
+Details are useful if you want to display information on an application like the
+current git revision, or how many requests have been serviced by the application.
+
+### Requirements
+
+  1. A detail **MUST** respond to `#call`
+  2. A hash **MUST** be returned
+  3. All hash keys **MUST** be strings
+
+### Example
+
 ```ruby
 # Your custom detail component
-class MyDetail < Wellness::Detail
-  def check
-    {
-      'foo' => 12,
-      'bar' => 31,
-      'qux' => options[:qux]
-    }
+module MyDetails
+  class GitRevisionDetail
+    def call
+      {
+        'revision' => revision
+      }
+    end
+
+    def revision
+      `git rev-parse --short HEAD`.chomp
+    end
   end
 end
-
 # Initialize the wellness system
 system = Wellness::System.new('my-app')
-system.use(MyDetail, 'something', { qux: 9000 })
+system.use('git', MyDetails::GitRevisionDetail.new)
 
 # Load it into your rack
 use(Wellness::Middleware, system)

data/Rakefile

@@ -1,5 +1,26 @@
 require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new(:spec)
-task :default => :spec
+namespace :test do
+  task :env do
+    $LOAD_PATH.unshift('lib', 'spec', 'test')
+  end
+
+  desc 'Runs only the units in this project'
+  task :units => [:env] do
+    Dir.glob('./test/**/*_test.rb') { |f| require f }
+  end
+
+  desc 'Runs only the specs in this project'
+  task :specs => [:env] do
+    Dir.glob('./spec/**/*_spec.rb') { |f| require f }
+  end
+
+  desc 'Runs all of the tests within this project'
+  task :all => [:units, :specs]
+end
+
+desc 'Runs all of the tests within this project'
+task :test => ['test:units']
+task :spec => ['test:specs']
+
+task(:default => 'test:all')

data/lib/wellness/detail.rb

@@ -1,19 +1,18 @@
 module Wellness
   # The parent class of all details that need to run.
   #
+  # @deprecated This is simply here help with migrating
+  #
   # @author Matthew A. Johnston (warmwaffles)
   class Detail
-    attr_reader :name, :options, :result
+    attr_reader :options
 
-    def initialize(name, options={})
-      @name = name
+    def initialize(options={})
       @options = options
-      @result = {}
     end
 
     def call
-      @result = self.check
-      self
+      self.check
     end
 
     # @return [Hash]
@@ -21,4 +20,4 @@ module Wellness
       {}
     end
   end
-end
+end

data/lib/wellness/detailed_report.rb

@@ -0,0 +1,64 @@
+require 'json'
+
+module Wellness
+  class DetailedReport
+    STATUSES = {
+      'HEALTHY' => 200,
+      'DEGRADED' => 500,
+      'UNHEALTHY' => 500
+    }
+
+    def initialize(system)
+      @system = system
+    end
+
+    def call
+      non_criticals = []
+      criticals = []
+
+      services = {}
+      @system.services.each do |name, service|
+        services[name] = service.call
+
+        if service.critical?
+          criticals << services[name]['status']
+        else
+          non_criticals << services[name]['status']
+        end
+      end
+
+      details = {}
+      @system.details.each do |name, detail|
+        details[name] = detail.call
+      end
+
+      healthy = criticals.all? { |s| s == 'HEALTHY' }
+      degraded = non_criticals.any? { |s| s == 'UNHEALTHY' }
+
+      if healthy
+        if degraded
+          status = 'DEGRADED'
+        else
+          status = 'HEALTHY'
+        end
+      else
+        status = 'UNHEALTHY'
+      end
+
+      results = {
+        'status'   => status,
+        'services' => services,
+        'details'  => details
+      }
+
+      render({json: results, status: STATUSES[status]})
+    end
+
+    def render(options={})
+      status   = options[:status]  || 200
+      response = JSON.dump(options[:json])
+
+      [status, { 'Content-Type' => 'application/json' }, [response]]
+    end
+  end
+end

data/lib/wellness/middleware.rb

@@ -1,3 +1,6 @@
+require 'wellness/simple_report'
+require 'wellness/detailed_report'
+
 module Wellness
   # This is to be put into the Rack environment.
   #
@@ -20,12 +23,12 @@ module Wellness
     def call(env)
       case env['PATH_INFO']
       when health_status_path
-        @system.simple_check
+        Wellness::SimpleReport.new(@system).call
       when health_details_path
-        @system.detailed_check
+        Wellness::DetailedReport.new(@system).call
       else
         @app.call(env)
       end
     end
   end
-end
+end

data/lib/wellness/service.rb

@@ -0,0 +1,17 @@
+module Wellness
+  # Wraps a callable object.
+  class Service
+    def initialize(callable, options={})
+      @callable = callable
+      @critical = options.fetch(:critical, true)
+    end
+
+    def critical?
+      !!@critical
+    end
+
+    def call
+      @callable.call
+    end
+  end
+end

data/lib/wellness/services/base.rb

@@ -2,8 +2,6 @@ module Wellness
   module Services
     # @author Matthew A. Johnston
     class Base
-      attr_reader :params, :result, :name
-
       # Load dependencies when the class is loaded. This makes putting requires
       # at the top of the file unnecessary. It plays nicely with the
       # auto loader.
@@ -11,39 +9,14 @@ module Wellness
         yield if block_given?
       end
 
-      # @param params [Hash]
-      def initialize(name, params={})
-        @name = name
-        @params = params
-        @result = {}
-      end
-
-      # Returns true if the service is healthy, otherwise false
-      # @return [TrueClass,FalseClass]
-      def healthy?
-        @result.fetch(:status, 'UNHEALTHY') == 'HEALTHY'
-      end
-
-      def passed_check
-        warn('#passed_check has been deprecated')
+      def initialize(args={})
       end
 
-      def failed_check
-        warn('#failed_check has been deprecated')
-      end
-
-      # @return [Wellness::Services::Base]
       def call
-        @result = self.check
-        self
-      end
-
-      # @return [Hash]
-      def check
         {
-          status: 'UNHEALTHY'
+          'status' => 'HEALTHY'
         }
       end
     end
   end
-end
+end

data/lib/wellness/services/postgres_service.rb

@@ -2,15 +2,24 @@ require 'wellness/services/base'
 
 module Wellness
   module Services
-    # @author Matthew A. Johnston
     class PostgresService < Base
       dependency do
-        require('pg')
+        require 'pg'
+      end
+
+      def initialize(args={})
+        @connection_options = {
+          host: args[:host],
+          port: args[:port],
+          dbname: args[:database],
+          user: args[:user],
+          password: args[:password]
+        }
       end
 
       # @return [Hash]
-      def check
-        case PG::Connection.ping(connection_options)
+      def call
+        case PG::Connection.ping(@connection_options)
         when PG::Constants::PQPING_NO_ATTEMPT
           ping_failed('no attempt made to ping')
         when PG::Constants::PQPING_NO_RESPONSE
@@ -24,24 +33,13 @@ module Wellness
 
       private
 
-      # @return [Hash]
-      def connection_options
-        {
-          host: self.params[:host],
-          port: self.params[:port],
-          dbname: self.params[:database],
-          user: self.params[:user],
-          password: self.params[:password]
-        }
-      end
-
       # @param message [String] the reason it failed
       # @return [Hash]
       def ping_failed(message)
         {
-          status: 'UNHEALTHY',
-          details: {
-            error: message
+          'status' => 'UNHEALTHY',
+          'details' => {
+            'error' => message
           }
         }
       end
@@ -49,8 +47,8 @@ module Wellness
       # @return [Hash]
       def ping_successful
         {
-          status: 'HEALTHY',
-          details: {
+          'status' => 'HEALTHY',
+          'details' => {
           }
         }
       end

data/lib/wellness/services/redis_service.rb

@@ -20,37 +20,31 @@ module Wellness
         'uptime_in_days'
       ]
 
-      dependency do
-        require('redis')
+      def initialize(args={})
+        @params = args
       end
 
       # @return [Hash]
-      def check
-        client = build_client
+      def call
+        client  = Redis.new(@params)
         details = client.info.select { |k, _| KEYS.include?(k) }
-        passed(details)
+        client.disconnect
+
+        {
+          'status' => 'HEALTHY',
+          'details' => details
+        }
       rescue Redis::BaseError => error
         failed(error)
       rescue Exception => error
         failed(error)
       end
 
-      def build_client
-        Redis.new(self.params)
-      end
-
-      def passed(details)
-        {
-          status: 'HEALTHY',
-          details: details
-        }
-      end
-
       def failed(error)
         {
-          status: 'UNHEALTHY',
-          details: {
-            error: error.message
+          'status' => 'UNHEALTHY',
+          'details' => {
+            'error' => error.message
           }
         }
       end

data/lib/wellness/services/sidekiq_service.rb

@@ -6,40 +6,43 @@ module Wellness
     class SidekiqService < Base
       KEYS = %w(redis_stats uptime_in_days connected_clients used_memory_human used_memory_peak_human)
 
-      dependency do
-        require 'redis'
-        require 'sidekiq'
+      def initialize(args={})
+        @params = args
       end
 
       # @return [Hash]
-      def check
+      def call
         sidekiq_stats = Sidekiq::Stats.new
+
         queue = Sidekiq::Queue.new
-        redis = Redis.new(self.params.fetch(:redis))
-        redis_stats = redis.info.select { |k, _| KEYS.include?(k) }
+        redis = Redis.new(@params.fetch(:redis))
+
+        redis_stats  = redis.info.select { |k, _| KEYS.include?(k) }
         workers_size = redis.scard('workers').to_i
 
+        redis.disconnect
+
         {
-          status: 'HEALTHY',
-          details: {
-            processed: sidekiq_stats.processed,
-            failed: sidekiq_stats.failed,
-            busy: workers_size,
-            enqueued: sidekiq_stats.enqueued,
-            scheduled: sidekiq_stats.scheduled_size,
-            retries: sidekiq_stats.retry_size,
-            default_latency: queue.latency,
-            redis: redis_stats
+          'status'  => 'HEALTHY',
+          'details' => {
+            'processed'       => sidekiq_stats.processed,
+            'failed'          => sidekiq_stats.failed,
+            'busy'            => workers_size,
+            'enqueued'        => sidekiq_stats.enqueued,
+            'scheduled'       => sidekiq_stats.scheduled_size,
+            'retries'         => sidekiq_stats.retry_size,
+            'default_latency' => queue.latency,
+            'redis'           => redis_stats
           }
         }
       rescue => error
         {
-          status: 'UNHEALTHY',
-          details: {
-            error: error.message
+          'status' => 'UNHEALTHY',
+          'details' => {
+            'error' => error.message
           }
         }
       end
     end
   end
-end
+end