leafy-health 0.3.0 → 0.3.1

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

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

data/leafy-logger/spec/appender_factories_spec.rb

@@ -0,0 +1,147 @@
+require_relative 'setup'
+require 'leafy/metrics/registry'
+require 'leafy/logger/factory'
+require 'leafy/logger/appender_factories'
+require 'fileutils'
+
+describe Leafy::Logger do
+
+  let( :factory ) do
+    f = Leafy::Logger::Factory.new
+    f.level :debug
+    f.configure( Leafy::Metrics::Registry.new, 'tester' )
+    f
+  end
+
+  let( :logger ) { Leafy::Logger::Factory.get_logger 'ROOT' }
+
+  describe Leafy::Logger::ConsoleAppenderFactory do
+
+    subject do
+      Leafy::Logger::ConsoleAppenderFactory.new do
+        target 'STDOUT'
+      end
+    end
+
+    it 'can set the target' do
+      expect(subject.target).to eq 'STDOUT'
+
+      subject.target = 'STDERR'
+      expect(subject.target).to eq 'STDERR'
+    end
+  end
+
+  describe Leafy::Logger::SyslogAppenderFactory do
+
+    subject do
+      Leafy::Logger::SyslogAppenderFactory.new
+    end
+
+    it 'can use default configuration with syslog' do
+      
+      factory.appenders subject
+
+      logger.debug( 'debug' )
+      logger.info( 'info' )
+
+      factory.stop
+
+      if not system("netstat -uln |grep :514")
+        last = File.read( '/var/log/syslog' ).split( /\n/ ).last
+        expect(last).to match /info$/
+      end
+    end
+
+    it 'can configure syslog' do
+      subject.port = 514
+      subject.include_stack_trace = false
+      subject.host = '127.0.0.1'
+      subject.facility = :auth
+      subject.stack_trace_prefix = '__'
+      subject.threshold = :debug
+
+      factory.appenders subject
+
+      logger.debug( 'debug' )
+      logger.info( 'info', java.lang.Exception.new( 'help me' ) )
+
+      factory.stop
+
+      if not system("netstat -uln |grep :514") and File.exist?( '/var/log/auth.log' )
+        last = File.read( '/var/log/auth.log' ).split( /\n/ ).last
+        expect(last).to match /info$/
+      end
+    end
+  end
+
+  describe Leafy::Logger::FileAppenderFactory do
+
+    subject do
+      Leafy::Logger::FileAppenderFactory.new
+    end
+
+    let( :log ) { File.join( File.dirname( __FILE__ ), 'test.log' ) }
+  
+    before { FileUtils.rm_f log }
+    after { FileUtils.rm_f log }
+
+    it 'can be configured with single file' do
+      subject.current_log_filename = log
+      subject.archive = false
+      subject.threshold = 'INFO'
+      subject.log_format = "%-5p [%d{ISO8601,UTC}] %c: %m%n%ex"
+
+      factory.appenders subject
+      logger.debug( 'debug' )
+      logger.info( 'info', java.lang.Exception.new( 'help' ) )
+
+      factory.stop
+
+      lines = File.read( log ).split( /\n/ )
+      lines.each do |line|
+        expect( line ).to match /^INFO.*info|^!.*help|^!.*at/
+      end
+    end
+
+    it 'can be configured via block' do
+      l = log
+      s = subject.class.new do
+        self.current_log_filename = l
+        self.archive = false
+        self.threshold = 'DEBUG'
+        self.log_format = "%-5p [%d{ISO8601,UTC}] %c: %m%n%rEx"
+      end
+
+      factory.appenders s
+      logger.debug( 'debug' )
+      logger.info( 'info', java.lang.Exception.new( 'help' ) )
+
+      factory.stop
+
+      lines = File.read( log ).split( /\n/ )
+      lines.each do |line|
+        expect( line ).to match /^INFO.*info|^DEBUG.*debug|^!.*help|^!.*at/
+      end
+    end
+
+    it 'can be configured with archived files' do
+      subject.current_log_filename = log
+      subject.archived_log_filename_pattern = "#{log}-%d.gz"
+      subject.archived_file_count = 2
+      subject.threshold = 'DEBUG'
+      subject.log_format = "%-5p [%d{ISO8601,UTC}] %c: %m%n%rEx"
+
+      factory.appenders subject
+
+      logger.debug( 'debug' )
+      logger.info( 'info', java.lang.Exception.new( 'help' ) )
+
+      factory.stop
+
+      lines = File.read( log ).split( /\n/ )
+      lines.each do |line|
+        expect( line ).to match /^INFO.*info|^DEBUG.*debug|^!.*help|^!.*at/
+      end
+    end
+  end
+end

data/leafy-logger/spec/factory_spec.rb

@@ -0,0 +1,176 @@
+require_relative 'setup'
+require 'leafy/metrics/registry'
+require 'leafy/logger/factory'
+require 'fileutils'
+
+describe Leafy::Logger::Factory do
+
+  subject do
+    f = Leafy::Logger::Factory.new
+    f.appenders( Leafy::Logger::FileAppenderFactory.new( log ) )
+    f.configure( Leafy::Metrics::Registry.new, 'tester' )
+    f
+  end
+
+  let( :log ) { File.join( File.dirname( __FILE__ ), 'test.log' ) }
+  let( :yaml ) { File.join( File.dirname( __FILE__ ), 'logging.yml' ) }
+  let( :logger1 ) { Leafy::Logger::Factory.get_logger 'my.app' }
+  let( :logger2 ) { Leafy::Logger::Factory.get_logger 'my.db' }
+
+  let( :factory_yaml ) { Leafy::Logger::Factory.new_from_yaml( yaml ) }
+  let( :reconfigured_yaml ) do
+    subject.reconfigure_from_yaml( yaml )
+    subject
+  end
+
+  let( :options ) { YAML.load( File.read( yaml ) ) }
+  let( :factory_options ) { Leafy::Logger::Factory.new_from_options( options ) }
+  let( :reconfigured_options ) do
+    subject.reconfigure_from_options( options )
+    subject
+  end
+
+  before { FileUtils.rm_f log }
+  after { FileUtils.rm_f log }
+
+  it 'can set appenders' do
+    expect( subject.appenders.size ).to eq 1
+
+    subject.appenders Leafy::Logger::ConsoleAppenderFactory.new
+    expect( subject.appenders.size ).to eq 1
+
+    subject.appenders( Leafy::Logger::ConsoleAppenderFactory.new,
+                       Leafy::Logger::FileAppenderFactory.new( log ) )
+    expect( subject.appenders.size ).to eq 2
+  end
+
+  it 'sets the default level' do
+    subject.level = 'INFO'
+    expect( subject.level ).to eq 'INFO'
+
+    subject.level 'DEBUG'    
+    expect( subject.level ).to eq 'DEBUG'
+  end
+
+  it 'can set the default log level' do
+    subject.level = 'INFO'
+
+    logger1.debug 'debug1'
+    logger1.info 'good'
+    logger1.warn 'good'
+    logger2.debug 'debug2'
+    logger2.info 'good'
+    logger2.warn 'good'
+ 
+    subject.stop
+
+    lines = File.read( log ).split( /\n/ )
+
+    expect( lines.size ).to eq 4
+    lines.each do |line|
+      expect( line ).to match /INFO|WARN/
+      expect( line ).to match /good/
+    end
+  end
+
+  it 'can set a specific log level' do
+    expect( subject.loggers ).to eq Hash[]
+
+    subject[ 'my.app' ] = 'WARN'
+
+    expect( subject.loggers ).to eq Hash[ 'my.app' => 'WARN' ]
+
+    logger1.debug 'debug1'
+    logger1.info 'info1'
+    logger1.warn 'good'
+    logger2.debug 'debug2'
+    logger2.info 'good'
+    logger2.warn 'good'
+
+    subject.stop
+
+    lines = File.read( log ).split( /\n/ )
+
+    expect( lines.size ).to eq 3
+    lines.each do |line|
+      expect( line ).to match /INFO|WARN/
+      expect( line ).to match /good/
+    end
+  end
+
+  it 'can set a specific log level' do
+    expect( subject.loggers ).to eq Hash[]
+
+    subject.loggers( 'my' => 'WARN' )
+
+    expect( subject.loggers ).to eq Hash[ 'my' => 'WARN' ]
+
+    logger1.debug 'debug1'
+    logger1.info 'info1'
+    logger1.warn 'good'
+    logger2.debug 'debug2'
+    logger2.info 'info2'
+    logger2.warn 'good'
+
+    subject.stop
+
+    lines = File.read( log ).split( /\n/ )
+
+    expect( lines.size ).to eq 2
+    lines.each do |line|
+      expect( line ).to match /WARN/
+      expect( line ).to match /good/
+    end
+
+  end
+
+  it 'fails on missing yaml configuration' do
+    expect {Leafy::Logger::Factory.new_from_yaml( yaml + '.gone' ) }.to raise_error( Exception )
+  end
+
+  it 'fails reconfigure on missing yaml configuration' do
+    expect {subject.reconfigure_from_yaml( yaml + '.gone' ) }.to raise_error( Exception )
+  end
+
+  [ :factory_yaml, :reconfigured_yaml ].each do |method|
+    it "can use a yaml configuration - #{method}" do
+      f = send( method )
+      expect( f.level ).to eq 'ERROR'
+      expect( f.loggers ).to eq 'com.example.app' => 'DEBUG'
+      expect( f.appenders.size ).to eq 3
+      # console
+      expect( f.appenders[0].threshold ).to eq 'DEBUG'
+      expect( f.appenders[0].target ).to eq 'STDERR'
+      # file
+      expect( f.appenders[1].threshold ).to eq 'INFO'
+      expect( f.appenders[1].current_log_filename ).to eq './logs/example.log'
+      expect( f.appenders[1].archived_log_filename_pattern ).to eq './logs/example-%d.log.gz'
+      expect( f.appenders[1].archived_file_count ).to eq 12
+      # syslog
+      expect( f.appenders[2].host ).to eq '127.0.0.1'
+      expect( f.appenders[2].port ).to eq 123
+      expect( f.appenders[2].facility ).to eq 'KERN'
+    end
+  end
+
+  [ :factory_options, :reconfigured_options ].each do |method|
+    it 'can use a hash configuration' do
+      f = send( method )
+      expect( f.level ).to eq 'ERROR'
+      expect( f.loggers ).to eq 'com.example.app' => 'DEBUG'
+      expect( f.appenders.size ).to eq 3
+      # console
+      expect( f.appenders[0].threshold ).to eq 'DEBUG'
+      expect( f.appenders[0].target ).to eq 'STDERR'
+      # file
+      expect( f.appenders[1].threshold ).to eq 'INFO'
+      expect( f.appenders[1].current_log_filename ).to eq './logs/example.log'
+      expect( f.appenders[1].archived_log_filename_pattern ).to eq './logs/example-%d.log.gz'
+      expect( f.appenders[1].archived_file_count ).to eq 12
+      # syslog
+      expect( f.appenders[2].host ).to eq '127.0.0.1'
+      expect( f.appenders[2].port ).to eq 123
+      expect( f.appenders[2].facility ).to eq 'KERN'
+    end
+  end
+end

data/leafy-logger/spec/logging.yml

@@ -0,0 +1,16 @@
+level: ERROR
+loggers:
+  com.example.app: DEBUG
+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

data/leafy-logger/spec/setup.rb

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

data/leafy-metrics/.gitignore

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

data/leafy-metrics/Gemfile

@@ -0,0 +1,7 @@
+#-*- mode: ruby -*-
+
+source 'https://rubygems.org'
+
+gemspec
+
+# vim: syntax=Ruby

data/leafy-metrics/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-metrics/README.md

@@ -0,0 +1,221 @@
+# Leafy-Metrics
+
+## installation
+
+via rubygems
+```
+gem install leafy-metrics
+```
+or add to your Gemfile
+```
+gem 'leafy-metrics'
+```
+
+installing the gem also takes care of the jar dependencies with jruby-1.7.16+
+
+## usage
+
+an instance of the registry ```Leafy::Metrics::Registry``` can register various metrics like gauge, timer, meter, counter and histogram and remove them again.
+
+     registry = Leafy::Metrics::Registry.new
+
+### gauge
+
+it can be other a given block or any object with a #call method returning the gauge - a number
+     
+    registry.register_gauge( 'app.uptime') do
+	  App.uptime
+	end
+
+or with an object
+
+    class UptimeGauge
+	  def call
+	    App.uptime
+      enf
+	end
+	registry.register_gauge( 'app.uptime', UptimeGauge.new )
+
+### timer
+
+a timer can measure the time an block needs to execute:
+
+    timer = registry.register_timer( 'app.timer' )
+	timer.time do
+      App.update_data
+    end
+
+### counter
+
+a counter simply counts i.e. can be incremented or decremented
+
+    counter = registry.register_counter( 'active.users.counter' )
+
+	# one new user logged on
+	counter.inc
+	
+	# three new users logged on
+	counter.inc 3
+	
+    # one user logged off
+    counter.dec
+
+    # two users logged off
+    counter.dec 2
+
+### meter
+
+    used = registry.register_meter( 'app.used' )
+
+mark the occurrence of an event
+
+	used.mark
+
+mark the occurrence of 'n' events
+
+	used.mark n
+
+
+### histogram
+
+measures the distribution of values in a stream of data using an exponentially decaying reservoir
+
+    histogram = registry.register_histogram( 'search.results' )
+    histogram.update( Search.last_result.size )
+
+### remove any metrics
+
+    registry.unregister( 'app.uptime )
+
+### note
+
+currently there is not further introspection on the registry and its health-check. with the ```Leafy::Json::MetricsWriter``` (from leafy-rack) you can get a json representation of the current **metrics report**
+
+    Leafy::Json::MetricsWriter.to_json( registry.metrics )
+
+## reporters
+
+all reporters use a builder pattern. there are following timeunits for
+configuration:
+
+* ```Leafy::Metrics::Reporter::DAYS```
+* ```Leafy::Metrics::Reporter::HOURS```
+* ```Leafy::Metrics::Reporter::MINUTES```
+* ```Leafy::Metrics::Reporter::SECONDS```
+* ```Leafy::Metrics::Reporter::MILLISECONDS```
+* ```Leafy::Metrics::Reporter::MICROSECONDS```
+* ```Leafy::Metrics::Reporter::NANOSECONDS```
+
+in all examples below ```metrics = Leafy::Metrics::Registry.new```
+
+### console reporter
+
+    require 'leafy/metrics/console_reporter'
+    reporter = metrics.reporter_builder( Leafy::Metrics::ConsoleReporter ).build
+	reporter.start( 1, Leafy::Metrics::Reporter::SECONDS )
+	....
+	reporter.stop
+
+or with all the possible configuration
+
+	reporter =  metrics.reporter_builder( Leafy::Metrics::ConsoleReporter )
+	    .convert_rates_to( Leafy::Metrics::Reporter::MILLISECONDS )
+        .convert_durations_to( Leafy::Metrics::Reporter::MILLISECONDS )
+        .output_to( STDERR )
+        .build
+
+or the config via a block
+
+	reporter =  metrics.reporter_builder( Leafy::Metrics::ConsoleReporter ) do
+	  convert_rates_to( Leafy::Metrics::Reporter::MILLISECONDS )
+      convert_durations_to( Leafy::Metrics::Reporter::MILLISECONDS )
+      output_to( STDERR )
+	end.build
+
+### csv reporter
+
+for each metric there will be a CSV file inside a given directory
+
+    require 'leafy/metrics/csv_reporter'
+    reporter = metrics.reporter_builder( Leafy::Metrics::CSVReporter )
+	    .build( 'metrics/directory' )
+	reporter.start( 1, Leafy::Metrics::Reporter::SECONDS )
+	....
+	reporter.stop
+
+or with all possible configuration
+
+	reporter = metrics.reporter_builder( Leafy::Metrics::CSVReporter )
+	    .convert_rates_to( Leafy::Metrics::Reporter::MILLISECONDS )
+        .convert_durations_to( Leafy::Metrics::Reporter::MILLISECONDS )
+        .build( 'metrics/directory' )
+
+or configuration via block
+
+	reporter = metrics.reporter_builder( Leafy::Metrics::CSVReporter ) do
+	  convert_rates_to( Leafy::Metrics::Reporter::MILLISECONDS )
+      convert_durations_to( Leafy::Metrics::Reporter::MILLISECONDS )
+    end.build( 'metrics/directory' )
+
+### graphite reporter
+
+there are three targets where to send the data
+
+* ```Leafy::Metrics::Graphite.new_tcp( hostname, port )```
+* ```Leafy::Metrics::Graphite.new_udp( hostname, port )```
+* ```Leafy::Metrics::Graphite.new_pickled( hostname, port, batchsize )```
+
+the latter is collecting a few report event and sends them as batch. the ```sender``` is one of the above targets.
+
+    require 'leafy/metrics/graphite_reporter'
+    reporter = metrics.reporter_builder( Leafy::Metrics::GraphiteReporter )
+	    .build_tcp( hostname, port )
+	reporter.start( 1, Leafy::Metrics::Reporter::SECONDS )
+	....
+	reporter.stop
+
+or with full configuration
+
+	reporter = metrics.reporter_builder( Leafy::Metrics::GraphiteReporter )
+	    .convert_rates_to( Leafy::Metrics::Reporter::MILLISECONDS )
+        .convert_durations_to( Leafy::Metrics::Reporter::MILLISECONDS )
+		.prefixed_with( 'myapp' )
+        .build( sender )
+
+or with block configuration
+
+	reporter = metrics.reporter_builder( Leafy::Metrics::GraphiteReporter ) do
+	  convert_rates_to( Leafy::Metrics::Reporter::MILLISECONDS )
+      convert_durations_to( Leafy::Metrics::Reporter::MILLISECONDS )
+	  prefixed_with( 'myapp' )
+    end.build_udp( host, port )
+
+### any third party reporter
+
+	reporter = metrics.reporter_builder( com.readytalk.metrics.StatsDReporter ) do
+	  convert_rates_to( Leafy::Metrics::Reporter::MILLISECONDS )
+      convert_durations_to( Leafy::Metrics::Reporter::MILLISECONDS )
+    end.build( host, port )
+
+or using the Java module reference
+
+	reporter = metrics.reporter_builder( Java::ComReadytalkMetrics::StatsDReporter ) do
+	  convert_rates_to( Leafy::Metrics::Reporter::MILLISECONDS )
+      convert_durations_to( Leafy::Metrics::Reporter::MILLISECONDS )
+      prefixed_with( 'app' )
+    end.build( host, port )
+
+## developement
+
+get all the gems and jars in place
+
+    gem install jar-dependencies --development
+	bundle install
+
+for running all specs
+
+	rake
+
+or
+
+    rspec spec/reporter_spec.rb