leafy-rack 0.3.0 → 0.3.1

data/leafy-health/lib/leafy-health_jars.rb

@@ -0,0 +1,7 @@
+# this is a generated file, to avoid over-writing it just delete this comment
+require 'jar_dependencies'
+
+require_jar( 'io.dropwizard.metrics', 'metrics-healthchecks', '3.1.0' )
+require_jar( 'org.slf4j', 'slf4j-api', '1.7.7' )
+require_jar( 'io.dropwizard.metrics', 'metrics-jvm', '3.1.0' )
+require_jar( 'io.dropwizard.metrics', 'metrics-core', '3.1.0' )

data/leafy-health/lib/leafy/health.rb

@@ -0,0 +1,2 @@
+require 'leafy-health_jars'
+require 'leafy/health/registry'

data/leafy-health/lib/leafy/health/health_check.rb

@@ -0,0 +1,72 @@
+require 'leafy/health'
+
+# add json serialization definition
+class com.codahale.metrics.health.HealthCheck::Result
+
+  attr_writer :data
+
+  def to_json( *args )
+    { :healthy => healthy?, :message => @data || message }.to_json( *args )
+  end
+end
+
+module Leafy
+  module Health
+    ThreadDeadlockHealthCheck = com.codahale.metrics.health.jvm.ThreadDeadlockHealthCheck
+    class HealthCheck < com.codahale.metrics.health.HealthCheck
+
+      def initialize( &block )
+        @block = block if block
+      end
+
+      # create healthy result object with given message
+      #
+      # param [String] optional result message, can be nil
+      # return [com.codahale.metrics.health.HealthCheck::Result]
+      def healthy( result = nil )
+        if result.is_a? Hash
+          r = com.codahale.metrics.health.HealthCheck::Result.healthy( result.to_json )
+          r.data = result
+          r
+        else
+          com.codahale.metrics.health.HealthCheck::Result.healthy( result )
+        end
+      end
+
+      # create unhealthy result object with given message
+      #
+      # param [String] result message
+      # return [com.codahale.metrics.health.HealthCheck::Result]
+      def unhealthy( result )
+        if result.is_a? Hash
+          r = com.codahale.metrics.health.HealthCheck::Result.unhealthy( result.to_json )
+          r.data = result
+          r
+        else
+          com.codahale.metrics.health.HealthCheck::Result.unhealthy( result )
+        end
+      end
+
+      def check
+        case result = call
+        when String
+          unhealthy( result )
+        when NilClass
+          healthy
+        when com.codahale.metrics.health.HealthCheck::Result
+          result
+        else
+          raise 'wrong result type'
+        end
+      end
+
+      def call
+        if @block
+          instance_eval( &@block )
+        else
+          'health check "call" method not implemented'
+        end
+      end
+    end
+  end
+end

data/leafy-health/lib/leafy/health/registry.rb

@@ -0,0 +1,55 @@
+require 'leafy/health'
+require 'leafy/health/health_check'
+module Leafy
+  module Health
+    class Registry
+
+      # state ofthe registry
+      attr_reader :health
+
+      def initialize
+        @health = com.codahale.metrics.health.HealthCheckRegistry.new
+      end
+
+      # register a HealthCheck under a given name
+      # 
+      # @param [String] name
+      # @param [String] instead of block any check object which responds to 'call'
+      # @yieldparam [HealthCheckRegistry::HealthCheck] which has convienient methods to create healthy and unhealthy results with message
+      # @yieldreturn [String] if the healthcheck fails return the message
+      # @yieldreturn [NilClass] if the healthcheck succeeds
+      # @yieldreturn [com.codahale.metrics.health.HealthCheck::Result] if the check produces its own result object
+      def register(name, check = nil, &block )
+        if check and not block_given? and check.is_a? com.codahale.metrics.health.HealthCheck
+          @health.register( name, check )
+        elsif check.nil? and block_given?
+          @health.register( name, HealthCheck.new( &block ) )
+        else
+          raise 'needs either a block and object with call method'
+        end
+      end
+ 
+      # unregister a HealthCheck for a given name
+      # 
+      # @param [String] name
+      def unregister(name)
+        @health.unregister(name)
+      end
+
+      # the names of all registered HealthCheck
+      # 
+      # @return [Array<String>] names of HealthCheck in order of their registration
+      def names
+        @health.names.to_a
+      end
+
+      # # run a healthcheck for a given name
+      # # 
+      # # @param [String] name
+      # # @return [Java::ComCodahaleMetricsHealth::HealthCheck::Result] result of the health-check
+      # def run_health_check(name) 
+      #   @health.runHealthCheck(name)
+      # end
+    end
+  end
+end

data/leafy-health/lib/leafy/health/version.rb

@@ -0,0 +1,6 @@
+module Leafy
+  module Health
+    VERSION = '0.3.1'.freeze
+  end
+end
+

data/leafy-health/spec/registry_spec.rb

@@ -0,0 +1,164 @@
+require 'leafy/health'
+require 'json'
+
+describe Leafy::Health::Registry do
+
+  subject { Leafy::Health::Registry.new }
+
+  it 'has thread-deadlock-health-check' do
+    subject.register( 'app', Leafy::Health::ThreadDeadlockHealthCheck.new )
+
+    expect(subject.names).to eq ['app']
+  end
+
+  it 'registers and unregister check as block' do
+    subject.register('me') do
+      'error'
+    end
+    expect(subject.names).to eq ['me']
+
+    results = subject.health.run_health_checks
+    expect(results.keys).to eq ['me']
+
+    first = results.values.to_array.first
+    expect(first.message).to eq 'error'
+    expect(first.healthy?).to eq false
+
+    subject.unregister('me')
+    expect(subject.names).to be_empty
+  end
+
+  it 'registers and unregister check as block using dsl' do
+    subject.register('me') do
+      healthy 'ok'
+    end
+    expect(subject.names).to eq ['me']
+
+    results = subject.health.run_health_checks
+    expect(results.keys).to eq ['me']
+
+    first = results.values.to_array.first
+    expect(first.message).to eq 'ok'
+    expect(first.healthy?).to eq true
+
+    subject.unregister('me')
+    expect(subject.names).to be_empty
+  end
+
+  it 'registers and unregister check as HealthCheck with block' do
+    subject.register('me',  Leafy::Health::HealthCheck.new {} )
+
+    expect(subject.names).to eq ['me']
+
+    results = subject.health.run_health_checks
+    expect(results.keys).to eq ['me']
+
+    first = results.values.to_array.first
+    expect(first.message).to be_nil
+    expect(first.healthy?).to eq true
+
+    subject.unregister('me')
+    expect(subject.names).to be_empty
+  end
+
+  it 'registers and unregister check as HealthCheck without implementing call' do
+    subject.register('me',  Leafy::Health::HealthCheck.new )
+
+    expect(subject.names).to eq ['me']
+
+    results = subject.health.run_health_checks
+    expect(results.keys).to eq ['me']
+
+    first = results.values.to_array.first
+    expect(first.message).to eq 'health check "call" method not implemented'
+    expect(first.healthy?).to eq false
+    
+    subject.unregister('me')
+    expect(subject.names).to be_empty
+  end
+
+  it 'fails register check as wrong object' do
+    expect { subject.register('me', Object.new ) }.to raise_error
+  end
+
+  describe Leafy::Health::HealthCheck do
+
+    it 'is healthy default with simple block' do
+      check = Leafy::Health::HealthCheck.new do
+        nil
+      end
+      expect( check.check.healthy? ).to be true
+      expect( check.check.message ).to be nil
+      expect( check.check.to_json ).to eq "{\"healthy\":true,\"message\":null}"
+    end
+
+    it 'is healthy with simple block' do
+      check = Leafy::Health::HealthCheck.new do
+        healthy 'happy'
+      end
+      expect( check.check.healthy? ).to be true
+      expect( check.check.message ).to eq 'happy'
+      expect( check.check.to_json ).to eq "{\"healthy\":true,\"message\":\"happy\"}"
+    end
+
+    it 'is healthy with structural message' do
+      check = Leafy::Health::HealthCheck.new do
+        healthy :msg => 'happy', :date => '11-11-2011'
+      end
+      expect( check.check.healthy? ).to be true
+      expect( check.check.to_json ).to eq "{\"healthy\":true,\"message\":{\"msg\":\"happy\",\"date\":\"11-11-2011\"}}"
+    end
+
+    it 'is healthy default' do
+      check = Leafy::Health::HealthCheck.new
+      def check.call; nil; end
+      expect( check.check.healthy? ).to be true
+      expect( check.check.message ).to eq nil
+    end
+
+    it 'is healthy' do
+      check = Leafy::Health::HealthCheck.new
+      def check.call; healthy( 'ok' ); end
+      expect( check.check.healthy? ).to be true
+      expect( check.check.message ).to eq 'ok'
+    end
+
+    it 'is unhealthy default with simple block' do
+      check = Leafy::Health::HealthCheck.new do
+        'sick'
+      end
+      expect( check.check.healthy? ).to be false
+      expect( check.check.message ).to eq 'sick'
+    end
+
+    it 'is unhealthy with simple block' do
+      check = Leafy::Health::HealthCheck.new do
+        unhealthy 'really sick'
+      end
+      expect( check.check.healthy? ).to be false
+      expect( check.check.message ).to eq 'really sick'
+    end
+
+    it 'is unhealthy with structural message' do
+      check = Leafy::Health::HealthCheck.new do
+        unhealthy :msg => 'oh je', :date => '11-11-2011'
+      end
+      expect( check.check.healthy? ).to be false
+      expect( check.check.to_json ).to eq "{\"healthy\":false,\"message\":{\"msg\":\"oh je\",\"date\":\"11-11-2011\"}}"
+    end
+
+    it 'is unhealthy default' do
+      check = Leafy::Health::HealthCheck.new
+      def check.call; 'not ok'; end
+      expect( check.check.healthy? ).to be false
+      expect( check.check.message ).to eq 'not ok'
+    end
+
+    it 'is unhealthy' do
+      check = Leafy::Health::HealthCheck.new
+      def check.call; unhealthy( 'not ok' ); end
+      expect( check.check.healthy? ).to be false
+      expect( check.check.message ).to eq 'not ok'
+    end
+  end
+end

data/leafy-health/spec/setup.rb

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

data/leafy-logger/.gitignore

@@ -0,0 +1,5 @@
+.yardoc
+doc
+pkg
+*.lock
+logs

data/leafy-logger/Gemfile

@@ -0,0 +1,9 @@
+#-*- mode: ruby -*-
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'leafy-metrics', :path => '../leafy-metrics'
+
+# vim: syntax=Ruby

data/leafy-logger/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Lookout
+
+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/leafy-logger/README.md

@@ -0,0 +1,174 @@
+# Leafy-Logger
+
+## installation
+
+via rubygems
+```
+gem install leafy-logger
+```
+or add to your Gemfile
+```
+gem 'leafy-logger
+```
+
+installing the gem also takes care of the jar dependencies with jruby-1.7.16+
+
+## usage
+
+default configuration
+```
+require 'leafy/logger/factory'
+require 'leafy/metrics/registry'
+
+f = Leafy::Logger::Factory.new
+f.configure( Leafy::Metrics::Registry.new, 'application' )
+
+l = Leafy::Logger::Factory.get_logger 'my.app'
+```
+
+the configure will setup the (default) appenders and register the metrics.
+
+there are more configurations for the logger Factory
+```
+require 'leafy/logger/appender_factories'
+
+f.level = 'INFO'
+f.loggers 'my.app' => 'WARN', 'my' => 'DEBUG'
+f.appenders( Leafy::Logger::ConsoleAppenderFactory.new,
+             Leafy::Logger::FileAppenderFactory.new('log/my.log' ) )
+f[ 'my.db' ] = 'INFO'
+```
+
+after the logger factory was configured once, any change of the log levels will result in a reconfiguration.
+
+## appender factories
+
+all appender factories have common set of attributes:
+```
+appender = Leafy::Logger::ConsoleAppenderFactory.new do
+  # :off, :trace, :debug, :info, :warn, :error, :all
+  self.threshold = :debug # default :all
+  self.log_format = "%-5p [%d{ISO8601,UTC}] %c: %m%n%ex"
+  self.queue_size = 1024 # default 256
+  # means nothing gets discarded
+  self.discarding_threshold = 0 # default -1
+end
+```
+
+### console appender factory
+
+```
+appender = Leafy::Logger::ConsoleAppenderFactory.new do
+  self.target 'STDOUT' # default is 'STDERR'
+end
+```
+
+### syslog appender factory
+
+```
+appender = Leafy::Logger::SyslogAppenderFactory.new do
+  self.host = '127.0.0.1' # default localhost
+  self.port = 514 # default 514
+  self.include_stack_trace = false # default true
+  # see Leafy::Logger::SyslogAppenderFactory.all_facilities
+  self.facility = :auth # default :local0
+  self.stack_trace_prefix = '__' # default '!'
+end
+```
+
+### file appender factory
+
+without archived files
+
+```
+appender = Leafy::Logger::SyslogAppenderFactory.new( 'logs/app.log' )
+```
+
+or
+
+```
+appender = Leafy::Logger::SyslogAppenderFactory.new do
+  self.current_log_filename = 'logs/app.log'
+end
+```
+
+with archived files
+
+```
+appender = Leafy::Logger::SyslogAppenderFactory.new do
+  self.current_log_filename = 'logs/app.log'
+  self.archive = true # default true
+  # files ending with .gz or .zip will packed respectively
+  self.archived_log_filename_pattern = 'logs/app-%d.log'
+  self.archived_file_count = 10 # default 5
+end
+```
+
+# using configurations
+
+a yaml file or an options hash can be used to configure the logger factory. once you have a logger factory you can reconfigure it with a yaml-file or options hash at runtime.
+
+## build logger factory from yaml file
+
+having a yaml file like (config/logging.yaml)
+
+```
+level: ERROR
+loggers:
+  com.example.app: DEBUG
+  com.example.db: INFO
+appenders:
+  - type: console
+    threshold: DEBUG
+    target: STDERR
+  - type: file
+    threshold: INFO
+    currentLogFilename: ./logs/example.log
+    archivedLogFilenamePattern: ./logs/example-%d.log.gz
+    archivedFileCount: 12
+  - type: syslog
+    host: 127.0.0.1
+    port: 123
+    facility: KERN
+```
+can be used to build ```LoggerFactory``` directly from this yaml file:
+
+```
+factory = Leafy::Logger::Factory.new_from_yaml( 'config/logging.yaml' )
+```
+
+having the same config as ```Hash``` can be used as well
+
+```
+options = YAML.load( File.read( 'config/logging.yaml' ) )
+factory = Leafy::Logger::Factory.new_from_options( options )
+```
+
+## reconfigure logger factory at runtime
+
+```
+factory.reconfigure_from_yaml( 'config/logging.yaml' )
+```
+
+or
+
+```
+factory.reconfigure_from_options( options )
+```
+
+## developement
+
+get all the gems and jars in place
+
+    gem install jar-dependencies --development
+	bundle install
+
+please make sure you are using jar-dependencies >= 0.1.8 !
+
+for running all specs
+
+	rake
+
+or a single one
+
+    rspec spec/reporter_spec.rb