observed 0.1.1

data/lib/observed/default/reporter.rb

@@ -0,0 +1,17 @@
+require 'observed/reporter'
+require 'observed/reporter/regexp_matching'
+
+module Observed
+  module Default
+    class Reporter < Observed::Reporter
+      include Observed::Reporter::RegexpMatching
+
+      attribute :writer
+
+      def report(tag, time, data)
+        writer.write tag, time, data
+      end
+
+    end
+  end
+end

data/lib/observed/default.rb

@@ -0,0 +1,2 @@
+require 'observed/default/observer'
+require 'observed/default/reporter'

data/lib/observed/hash/builder.rb

@@ -0,0 +1,24 @@
+require 'observed/hash/key_path_encoding'
+
+module Observed
+  module Hash
+    class Builder
+      include Observed::Hash::KeyPathEncoding
+
+      def initialize(defaults={})
+        @hash = defaults.dup
+      end
+
+      def []=(key_path, value)
+        at_key_path_on_hash @hash, key_path, create_if_missing: true do |h, k|
+          h[k] = value
+        end
+      end
+
+      def build
+        @hash
+      end
+
+    end
+  end
+end

data/lib/observed/hash/fetcher.rb

@@ -0,0 +1,19 @@
+require 'observed/hash/key_path_encoding'
+
+module Observed
+  module Hash
+    class Fetcher
+      include Observed::Hash::KeyPathEncoding
+
+      def initialize(hash)
+        @hash = hash || fail('The hash must not be nil')
+      end
+
+      def [](key_path)
+        at_key_path_on_hash @hash, key_path, create_if_missing: false do |h, k|
+          h[k]
+        end
+      end
+    end
+  end
+end

data/lib/observed/hash/key_path_encoding.rb

@@ -0,0 +1,62 @@
+module Observed
+  module Hash
+    module KeyPathEncoding
+
+      # Decodes the key path such as 'foo.bar' to dig into the hash and returns `hash[:foo][:bar]`
+      # @param [Hash] hash The hash to be dug
+      # @param [String] key_path The key path which is consisted of one or more keys from the parent-to-child order,
+      #                          e.g. 'foo.bar' which is consisted of the keys 'foo' and 'bar' where
+      #                          the former is the key for the root hash and the latter if is the key for
+      #                          the nested hash in `{foo: {bar: 'the_value'}}`
+      # @param [Hash<Symbol,Boolean>] options
+      # @option options [Boolean] :create_if_missing when `true` the intermediate hash objects under the consisting keys
+      #                                                   in the key path is created automatically.
+      #                                                   In other words, you automatically get `{foo:bar:{}}` when the
+      #                                                   hash is `{}` and the key_path is `foo.bar.baz`
+      # @yield yields the hash to be updated or read and the last key to reach the value at the specified key path
+      # @yieldparam [Hash] hash The hash which has the second to the last key in the key_path. e.g. `{bar:1}` where the
+      #                         input hash object is `{foo:{bar:1}}` and the key path is 'foo.bar'
+      # @yieldparam [String|Symbol] key 'bar' in the example for the parameter `hash` immediately above.
+      # @yieldreturn [Object] The return value of this method is the return value of the given block
+      # @returns The result of the given block
+      def at_key_path_on_hash(hash, key_path, options = {}, &block)
+        create_if_missing = options[:create_if_missing]
+
+        if create_if_missing.nil?
+          fail "The key :create_if_missing must be exist in #{options}"
+        end
+
+        if hash.nil?
+          fail 'The hash must not be nil'
+        end
+
+        first, *rest = case key_path
+                       when Array
+                         key_path
+                       when String
+                         key_path.split(".")
+                       when Symbol
+                         key_path
+                       end
+        key_str = first.to_s
+        key_sym = first.intern
+        key = if hash.key? key_str
+                key_str
+              else
+                key_sym
+              end
+        if rest.empty?
+          block.call hash, key
+        else
+          child = hash[key]
+          if child
+            at_key_path_on_hash(child, rest, options, &block)
+          elsif create_if_missing
+            hash[key] = created = {}
+            at_key_path_on_hash(created, rest, options, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/observed/hash.rb

@@ -0,0 +1,3 @@
+require 'observed/hash/builder'
+require 'observed/hash/fetcher'
+require 'observed/hash/key_path_encoding'

data/lib/observed/observer.rb

@@ -0,0 +1,18 @@
+require 'observed/configurable'
+require 'observed/pluggable'
+
+module Observed
+
+  class Observer
+    include Pluggable
+    include Configurable
+
+    attribute :tag
+    attribute :system
+
+    def observe
+      raise NotImplementedError.new
+    end
+
+  end
+end

data/lib/observed/observer_helpers/timer.rb

@@ -0,0 +1,37 @@
+module Observed
+  module ObserverHelpers
+    module Timer
+
+      require 'timeout'
+
+      def time(options={}, &block)
+        timeout_in_seconds = options[:timeout_in_seconds] ||
+            fail("The key `:timeout_in_seconds` must be exist in the options: #{options}")
+
+        begin
+          before = system.now
+          r = Timeout::timeout(timeout_in_seconds) do
+            { status: :success, result: block.call }
+          end
+          after = system.now
+          elapsed_time = after - before
+          r[:elapsed_time] = elapsed_time
+          r
+        rescue Timeout::Error => e1
+          { status: :error, error: {message: "#{e2.message}\n#{e2.backtrace}"}, timed_out: true }
+        rescue => e2
+          { status: :error, error: {message: "#{e2.message}\n#{e2.backtrace}"} }
+        end
+      end
+
+      def time_and_report(options={}, &block)
+        tag = options[:tag] || (self.respond_to?(:tag) && self.tag) || fail("The key `:tag` must be exist in the options: #{options}")
+        format = options[:format] || ->(r){ r }
+        result = time(options, &block)
+
+        system.report("#{tag}.#{result[:status]}", format.call(result))
+      end
+
+    end
+  end
+end

data/lib/observed/pluggable.rb

@@ -0,0 +1,34 @@
+module Observed
+  module Pluggable
+
+    module ClassMethods
+      def plugins
+        @plugins ||= []
+      end
+
+      def inherited(klass)
+        plugins << klass
+      end
+
+      def plugin_name(plugin_name=nil)
+        @plugin_name = plugin_name if plugin_name
+        @plugin_name
+      end
+
+      def find_plugin_named(plugin_name)
+        plugins.find { |plugin| plugin.plugin_name == plugin_name }
+      end
+
+      def select_named_plugins
+        plugins.select(&:plugin_name)
+      end
+    end
+
+    class << self
+      def included(klass)
+        klass.extend ClassMethods
+      end
+    end
+
+  end
+end

data/lib/observed/reader.rb

@@ -0,0 +1,14 @@
+require 'observed/configurable'
+require 'observed/pluggable'
+
+module Observed
+  class Reader
+    include Observed::Configurable
+    include Observed::Pluggable
+
+    def read
+      fail 'Not Implemented'
+    end
+
+  end
+end

data/lib/observed/reporter/regexp_matching.rb

@@ -0,0 +1,11 @@
+module Observed
+  class Reporter
+    module RegexpMatching
+
+      def match(tag)
+        tag_pattern.match(tag)
+      end
+
+    end
+  end
+end

data/lib/observed/reporter.rb

@@ -0,0 +1,25 @@
+require 'observed/configurable'
+require 'observed/pluggable'
+
+module Observed
+  class Reporter
+    include Configurable
+    include Pluggable
+
+    # !@attribute [r] tag_pattern
+    #   @return [Regexp]
+    attribute :tag_pattern
+
+    attribute :system
+
+    # @param [String] tag
+    def match(tag)
+      raise NotImplementedError.new
+    end
+
+    def report(tag, time, data)
+      raise NotImplementedError.new
+    end
+
+  end
+end

data/lib/observed/system.rb

@@ -0,0 +1,109 @@
+require 'observed/observer'
+require 'observed/reporter'
+
+module Observed
+  class System
+
+    def initialize(args={})
+      @config = args[:config] if args[:config]
+      @logger = args[:logger] if args[:logger]
+    end
+
+    def config=(config)
+      @config = config
+    end
+
+    def config
+      @config
+    end
+
+    def report(tag, time, data=nil)
+      if data.nil?
+        data = time
+        time = self.now
+      end
+      reporters.each do |reporter|
+        if reporter.match(tag)
+          reporter.report(tag, time, data)
+        end
+      end
+    end
+
+    def run(observation_name=nil)
+
+      if observation_name
+        observers_to_run = observers.reject { |o| o.tag != observation_name }
+        fail "No configuration found for observation name '#{observation_name}'" if observers_to_run.empty?
+      else
+        observers_to_run = observers
+      end
+
+      observers_to_run.map do |input|
+        input.observe
+      end
+
+    end
+
+    def now
+      Time.now
+    end
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    private
+
+    def observers
+      config.observers
+    end
+
+    def reporters
+      config.reporters
+    end
+
+  end
+
+  class YAML
+    def observers
+      config.observers
+      @observers ||= begin
+
+        observer_configs = config.observers
+
+        observers = {}
+
+        observer_configs.each do |tag, input_config|
+          plugin_name = input_config[:plugin] || fail(RuntimeError, %Q|Missing plugin name for the tag "#{tag}" in "#{input_config}" in "#{config}".|)
+          plugin = observer_plugins[plugin_name] || fail(RuntimeError, %Q|The plugin named "#{plugin_name}" is not found in plugins list "#{observer_plugins}".|)
+          updated_config = input_config.merge(tag: tag)
+          observer = plugin.new(updated_config)
+          observer.configure(system: self, logger: logger)
+          observers[tag] = observer
+        end
+
+        observers
+      end
+    end
+
+    def reporters
+      @reporters ||= begin
+
+        reporter_configs = config.reporters
+
+        reporters = {}
+
+        reporter_configs.each do |tag_pattern, output_config|
+          plugin_name = output_config[:plugin] || fail(RuntimeError, %Q|Missing plugin name for the output for "#{tag_pattern}" in "#{output_config}" in #{config}.|)
+          plugin = reporter_plugins[plugin_name] || fail(RuntimeError, %Q|The plugin named "#{plugin_name}" is not found in plugins list "#{reporter_plugins}".|)
+          updated_config = output_config.merge(tag_pattern: Regexp.new(tag_pattern))
+          reporter = plugin.new(updated_config)
+          reporter.configure(system: self, logger: logger)
+          reporters[tag_pattern] = reporter
+        end
+
+        reporters
+      end
+    end
+  end
+end

data/lib/observed/version.rb

@@ -0,0 +1,3 @@
+module Observed
+  VERSION = '0.1.1'
+end

data/lib/observed/writer.rb

@@ -0,0 +1,14 @@
+require 'observed/configurable'
+require 'observed/pluggable'
+
+module Observed
+  class Writer
+    include Observed::Configurable
+    include Observed::Pluggable
+
+    def write(tag, time, data)
+      fail 'Not Implemented'
+    end
+
+  end
+end

data/lib/observed.rb

@@ -0,0 +1,77 @@
+require 'observed/version'
+require 'observed/config_builder'
+require 'observed/system'
+require 'observed/config_dsl'
+require 'observed/builtin_plugins'
+require 'forwardable'
+
+# The module to provide DSL to describe Observed configuration, intended to be used by including to Ruby's `main` object
+# like Clockwork(https://github.com/tomykaira/clockwork) does in their configuration file(a.k.a `clockwork.rb`).
+#
+# Take this as the `Builder` for Observed's configuration which is has global state.
+# As it has global state, we have to call `Observed#init!` before building multiple Observed configurations through
+# this module.
+#
+# @example
+# require 'observed'
+# include Observed
+#
+# require 'observed/http'
+# require_relative 'your_plugin'
+#
+# observe 'myservice.response', { plugin: 'http', method: 'get', url: 'http://localhost:3000' }
+# report /myservice.response/, { plugin: 'stdout' }
+#
+# #=> Now we can obtain the described configuration by calling `Observed.config`
+module Observed
+
+  class Singleton
+    extend Forwardable
+
+    def_delegators :@observed, :require_relative, :observe, :report, :write, :read, :config, :load!, :working_directory
+
+    # Call this method before you are going to build 2nd or later Observed configuration using this module.
+    # Refrain that `Observed` object is a builder for Observed configuration and it has global state.
+    # We have to reset its state via this `init!` method before building next configurations after the first one.
+    def init!
+      @sys = Observed::System.new
+      config_builder = Observed::ConfigBuilder.new(system: @sys)
+      @observed = Observed::ConfigDSL.new(builder: config_builder)
+    end
+
+    def run(tag=nil)
+      @sys.config = self.config
+      @sys.run(tag)
+    end
+
+    def configure(*args)
+      @observed.send :configure, *args
+    end
+  end
+
+  class << self
+    def included(klass)
+      ensure_singleton_initialized
+    end
+
+    def extended(klass)
+      ensure_singleton_initialized
+    end
+
+    def ensure_singleton_initialized
+      @@singleton ||= begin
+        s = Singleton.new
+        s.init!
+        s
+      end
+    end
+  end
+
+  extend Forwardable
+
+  def_delegators :@@singleton, :run, :init!, :configure, :require_relative, :observe, :report, :write, :read, :config,
+                 :load!, :working_directory
+
+  extend self
+
+end

data/observed.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'observed/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "observed"
+  spec.version       = Observed::VERSION
+  spec.authors       = ["KUOKA Yusuke"]
+  spec.email         = ["yusuke.kuoka@gree.net"]
+  spec.description   = %q{Observed}
+  spec.summary       = %q{Observed is a health-check framework for various services}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "fakefs"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "aruba"
+end

data/plugins/observed-fluentd/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~
+*.log
+bin/

data/plugins/observed-fluentd/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in observed-fluentd.gemspec
+gemspec
+
+gem 'clockwork', :group => :test
+gem 'fluentd', :group => :test
+gem 'cucumber', :group => :test
+gem 'aruba', :group => :test
+gem 'observed', :group => :test
+gem 'observed-http', :group => :test
+gem 'observed-clockwork', :group => :test

data/plugins/observed-fluentd/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 GREE, Inc.
+
+MIT License
+
+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/plugins/observed-fluentd/README.md

@@ -0,0 +1,99 @@
+# Observed::Fluentd
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'observed-fluentd'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install observed-fluentd
+
+Or `git clone` the sources and install by using rake:
+
+    $ rake install
+
+## Usage
+
+First of all, we need to install the fluentd to which we send observed data:
+
+    $ gem install fluentd
+
+Then we should configure Fluentd to see data which will be sent from observed-fluentd:
+
+    $ fluentd --setup fluent.d
+    Installed fluent.d/fluent.conf.
+
+Ensure that the following 2 parts exist in the generated fluent.conf:
+
+     <source>
+       type forward
+     </source>
+
+    <match debug.**>
+      type stdout
+    </match>
+
+Now we can run Fluentd:
+
+    $ fluentd -c fluent.d/fluent.conf
+
+Install observed-fluentd:
+
+    $ gem build observed-fluentd.gemspec
+    $ gem install observed-fluentd
+    $ gem install observed-http
+    $ gem install observed-clockwork
+
+Create the observed.conf like:
+
+    require 'observed/builtin_plugins'
+    require 'observed/http'
+    require 'observed/fluentd'
+
+    observe 'myservice', {
+      plugin: 'http',
+      method: 'get',
+      url: 'http://localhost/',
+      timeout_in_milliseconds: 3000,
+    }
+
+    match /myservice.*/, {
+      plugin: 'fluentd',
+      host: 'localhost',
+      port: 24224,
+      tag: 'debug.myservice'
+    }
+
+Run clockwork and trigger observed:
+
+    $ cd observe.d/
+    $ clockwork clockwork.rb
+
+Find data sent from Observed in the Fluentd output:
+
+    2013-11-01T07:55:09Z	debug.myservice	{"status":"success","result":"Get http://localhost/","elapsed_time":0.013686}
+
+Now you can do anything utilizing Fluent's rich features and plugins.
+
+## Developping
+
+To run cucumber tests, execute:
+
+   $ bundle install --binstubs
+   $ bin/cucumber features
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/plugins/observed-fluentd/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"