observed 0.1.1

data/integrations/observed-clockwork/features/run_observed_inside_clockwork.feature

@@ -0,0 +1,59 @@
+Feature: Running Observed inside Clockwork
+
+  In order to integrate Observed with Clockwork,
+  I want to configure Clockwork to run Observed.
+
+  Scenario: Create a .rb file containing Observed code and run it with the ruby command
+    Given a file named "observed.conf" with:
+    """
+    require 'observed/builtin_plugins'
+    require_relative 'foo_plugin'
+
+    observe 'foo_1', via: 'foo'
+
+    report /foo_1/, via: 'stdout'
+    """
+    Given a file named "foo_plugin.rb" with:
+    """
+    module OneshotSpec
+      class FooPlugin < Observed::Observer
+
+        plugin_name 'foo'
+
+        default timeout_in_milliseconds: 5000
+        default number_of_trials: 10
+
+        def observe
+          sleep_duration = rand / 20
+          sleep sleep_duration
+          system.report(tag, "Foo #{sleep_duration}")
+
+          # For testing purpose,
+          # we want the `clockwork` process to exit as soon as we ran Observed to report the test
+          # output to the stdout
+          exit
+        end
+
+        def logger
+          @logger ||= Logger.new(STDOUT)
+        end
+      end
+    end
+    """
+    Given a file named "clockwork.rb" with:
+    """
+    require 'clockwork'
+    require 'observed/clockwork'
+
+    include Clockwork
+    include Observed::Clockwork
+
+    register_observed_handler :config_file => File.dirname(__FILE__) + '/observed.conf'
+
+    every(10.seconds, 'foo_1')
+    """
+    When I run `clockwork clockwork.rb`
+    Then the output should contain:
+    """
+    foo_1 Foo
+    """

data/integrations/observed-clockwork/features/support/env.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'aruba/cucumber'
+
+World(Aruba::Api)
+
+Before do
+  @aruba_timeout_seconds = 20
+end

data/integrations/observed-clockwork/lib/observed/clockwork/version.rb

@@ -0,0 +1,5 @@
+module Observed
+  module Clockwork
+    VERSION = "0.1.0"
+  end
+end

data/integrations/observed-clockwork/lib/observed/clockwork.rb

@@ -0,0 +1,20 @@
+require 'clockwork'
+require 'observed'
+require "observed/clockwork/version"
+require "observed/application"
+
+module Observed
+  module Clockwork
+    extend self
+
+    def register_observed_handler(args)
+      Observed.init!
+      Observed.configure args
+      Observed.load! args[:config_file]
+      ::Clockwork.handler do |job|
+        Observed.run job
+      end
+    end
+
+  end
+end

data/integrations/observed-clockwork/observed-clockwork.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'observed/clockwork/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "observed-clockwork"
+  spec.version       = Observed::Clockwork::VERSION
+  spec.authors       = ["KUOKA Yusuke"]
+  spec.email         = ["yusuke.kuoka@gree.net"]
+  spec.description   = %q{Observed Clockwork Integration}
+  spec.summary       = %q{An integration of Observed with Clockwork}
+  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_dependency 'clockwork'
+  spec.add_dependency 'daemons'
+  spec.add_dependency 'observed', "~> 0.1.0"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "aruba"
+end

data/lib/observed/application/oneshot.rb

@@ -0,0 +1,114 @@
+require 'logger'
+require 'optparse'
+require 'pathname'
+
+require 'observed/config'
+require 'observed/config_builder'
+require 'observed/config_dsl'
+require 'observed/observer'
+require 'observed/system'
+
+module Observed
+
+  module Application
+    # The application which is usually ran from CLI to run health-checks and write the results to a log file, and then exit.
+    # An "Oneshot" application is the opposite of a "Daemon" or "Resident" application.
+    class Oneshot
+
+      class InvalidArgumentError < RuntimeError; end
+
+      # @param [Observed::Config] config
+      def initialize(config, sys)
+        @config = config
+        @system = sys
+      end
+
+      def config
+        @config || fail('Missing configuration for Application::Oneshot')
+      end
+
+      def run(observation_name=nil)
+        system.run(observation_name)
+      end
+
+      def logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      class << self
+        def from_argv(argv)
+
+          command_line_args = argv.dup
+
+          args = {}
+
+          opts = OptionParser.new
+          opts.accept(Pathname) do |s,|
+            Pathname.new(s)
+          end
+          opts.on('-d', '--debug') do
+            args[:debug] = true
+          end
+          opts.on('-l LOG_FILE', '--l LOG_FILE', Pathname) do |log_file|
+            args[:log_file] = log_file
+          end
+
+          opts.parse!(command_line_args)
+
+          if command_line_args.size != 1
+            fail InvalidArgumentError, "Invalid number of arguments #{command_line_args.size} where arguments are #{command_line_args}"
+          end
+
+          args[:config_file] = command_line_args.first
+
+          create(args)
+        end
+
+        # @param [Hash<Symbol,String>] args
+        # @option args [Array<String>] :argv The Ruby's `ARGV` like object which is treated as intialization parameters for Oneshoft application.
+        def create(args)
+          logger_out = if args[:log_file]
+                         File.open(args[:log_file], 'a')
+                       else
+                         STDOUT
+                       end
+          logger = Logger.new(logger_out)
+          logger.level = if args[:debug]
+                           Logger::DEBUG
+                         else
+                           Logger::INFO
+                         end
+          sys = Observed::System.new(logger: logger)
+          config = if args[:yaml_file]
+                     YAML.load_file(args[:yaml_file])
+                   elsif args[:config_file]
+                     path = args[:config_file]
+                     config_builder = Observed::ConfigBuilder.new(system: sys, logger: logger)
+                     config_dsl = Observed::ConfigDSL.new(builder: config_builder, logger: logger)
+                     config_dsl.eval_file(path)
+                     config_dsl.config
+                   elsif args[:config]
+                     c = args[:config]
+                     c
+                   else
+                     fail 'No configuration provided'
+                   end
+          config = if config.is_a? Hash
+                     Observed::Config.create(config)
+                   else
+                     config
+                   end
+          sys.config = config
+          new(config, sys)
+        end
+      end
+
+      private
+
+      def system
+        @system
+      end
+
+    end
+  end
+end

data/lib/observed/application.rb

@@ -0,0 +1 @@
+require 'observed/application/oneshot'

data/lib/observed/builtin_plugins/file.rb

@@ -0,0 +1,49 @@
+require 'observed/hash/fetcher'
+require 'observed/reporter'
+require 'observed/reporter/regexp_matching'
+
+module Observed
+  module BuiltinPlugins
+    class File < Observed::Reporter
+
+      include Observed::Reporter::RegexpMatching
+
+      UNDEFINED = Object.new
+
+      attribute :format, default: -> tag, time, data { "#{Time.at(time)} #{tag} #{data}" }
+      attribute :path
+      attribute :mode, default: :append
+
+      # @param [String] tag
+      # @param [Time] time
+      # @param [Hash] data
+      def report(tag, time, data)
+        num_params = format.parameters.size
+        formatted_data = case num_params
+                         when 3
+                           format.call(tag, time, data)
+                         when 4
+                           format.call(tag, time, data, Observed::Hash::Fetcher.new(data))
+                         else
+                           fail "Number of parameters for the function for the key :format must be 3 or 4, but was #{num_params}(#{format.parameters}"
+                         end
+        mode = case self.mode
+               when :append, 'a'
+                 'a'
+               when :overwrite, 'w'
+                 'w'
+               else
+                 fail "Unsupported value for the parameter `:mode`: Supported values are :append, :overwrite, " +
+                     "'a', 'w'. The specified value is #{self.mode.inspect}"
+               end
+        ::File.open(path, mode) do |f|
+          f.puts formatted_data
+        end
+      end
+
+      def self.plugin_name
+        'file'
+      end
+    end
+  end
+end

data/lib/observed/builtin_plugins/stdout.rb

@@ -0,0 +1,35 @@
+require 'observed/hash/fetcher'
+require 'observed/observer'
+require 'observed/reporter'
+require 'observed/reporter/regexp_matching'
+
+module Observed
+  module BuiltinPlugins
+    class Stdout < Observed::Reporter
+
+      include Observed::Reporter::RegexpMatching
+
+      attribute :format, default: -> tag, time, data { "#{Time.at(time)} #{tag} #{data}" }
+
+      # @param [String] tag
+      # @param [Time] time
+      # @param [Hash] data
+      def report(tag, time, data)
+        num_params = format.parameters.size
+        formatted_data = case num_params
+        when 3
+          format.call(tag, time, data)
+        when 4
+          format.call(tag, time, data, Observed::Hash::Fetcher.new(data))
+        else
+          fail "Number of parameters for the function for the key :format must be 3 or 4, but was #{num_params}(#{format.parameters}"
+        end
+        puts formatted_data
+      end
+
+      def self.plugin_name
+        'stdout'
+      end
+    end
+  end
+end

data/lib/observed/builtin_plugins.rb

@@ -0,0 +1,2 @@
+require 'observed/builtin_plugins/file'
+require 'observed/builtin_plugins/stdout'

data/lib/observed/config.rb

@@ -0,0 +1,27 @@
+require 'observed/configurable'
+
+module Observed
+  # The configuration for Observed which may be built by Observed::Builder,
+  # which may contains configured writers, readers, reporters, observers.
+  class Config
+
+    include Observed::Configurable
+
+    # !@attribute [rw] writers
+    #  @return [Array<Observed::Writer>]
+    attribute :writers
+
+    # !@attribute [rw] readers
+    #  @return [Array<Observed::Reader>]
+    attribute :readers
+
+    # !@attribute [rw] reporters
+    #  @return [Array<Observed::Reporter>]
+    attribute :reporters
+
+    # !@attribute [rw] observers
+    #  @return [Array<Observed::Observer>]
+    attribute :observers
+
+  end
+end

data/lib/observed/config_builder.rb

@@ -0,0 +1,167 @@
+require 'observed/config'
+require 'observed/configurable'
+require 'observed/default'
+require 'observed/hash'
+require 'observed/reader'
+require 'observed/writer'
+
+module Observed
+
+  class ConfigBuilder
+    include Observed::Configurable
+
+    def initialize(args)
+      @writer_plugins = args[:writer_plugins] if args[:writer_plugins]
+      @reader_plugins = args[:reader_plugins] if args[:reader_plugins]
+      @observer_plugins = args[:observer_plugins] if args[:observer_plugins]
+      @reporter_plugins = args[:reporter_plugins] if args[:reporter_plugins]
+      @system = args[:system] || fail("The key :system must be in #{args}")
+      @logger = args[:logger] || Logger.new(STDOUT, Logger::DEBUG)
+    end
+
+    def system
+      @system
+    end
+
+    def writer_plugins
+      @writer_plugins || select_named_plugins_of(Observed::Writer)
+    end
+
+    def reader_plugins
+      @reader_plugins || select_named_plugins_of(Observed::Reader)
+    end
+
+    def observer_plugins
+      @observer_plugins || select_named_plugins_of(Observed::Observer)
+    end
+
+    def reporter_plugins
+      @reporter_plugins || select_named_plugins_of(Observed::Reporter)
+    end
+
+    def select_named_plugins_of(klass)
+      plugins = {}
+      klass.select_named_plugins.each do |plugin|
+        plugins[plugin.plugin_name] = plugin
+      end
+      plugins
+    end
+
+    def build
+      Observed::Config.new(
+          writers: writers,
+          readers: readers,
+          observers: observers,
+          reporters: reporters
+      )
+    end
+
+    # @param [Regexp] tag_pattern The pattern to match tags added to data from observers
+    # @param [Hash] args The configuration for each reporter which may or may not contain (1) which reporter plugin to
+    # use or which writer plugin to use (in combination with the default reporter plugin) (2) initialization parameters
+    # to instantiate the reporter/writer plugin
+    def report(tag_pattern, args)
+      writer = write(args)
+      tag_pattern || fail("Tag pattern missing: #{tag_pattern} where args: #{args}")
+      reporter = if writer
+                   Observed::Default::Reporter.new.configure(tag_pattern: tag_pattern, writer: writer, system: system)
+                 else
+                   via = args[:via] || args[:using]
+                   with = args[:with] || args[:which] || {}
+                   with = ({logger: @logger}).merge(with).merge({tag_pattern: tag_pattern})
+                   plugin = reporter_plugins[via] ||
+                       fail(RuntimeError, %Q|The reporter plugin named "#{via}" is not found in "#{reporter_plugins}"|)
+                   plugin.new(with)
+                 end
+      begin
+        reporter.match('test')
+      rescue => e
+        fail "A mis-configured reporter plugin found: #{reporter}"
+      rescue NotImplementedError => e
+        builtin_methods = Object.methods
+        info = (reporter.methods - builtin_methods).map {|sym| reporter.method(sym) }.map(&:source_location).compact
+        fail "Incomplete reporter plugin found: #{reporter}, defined in: #{info}"
+      end
+
+      reporters << reporter
+      reporter
+    end
+
+    # @param [String] tag The tag which is assigned to data which is generated from this observer, and is sent to
+    # reporters later
+    # @param [Hash] args The configuration for each observer which may or may not contain (1) which observer plugin to
+    # use or which reader plugin to use (in combination with the default observer plugin) (2) initialization parameters
+    # to instantiate the observer/reader plugin
+    def observe(tag, args)
+      reader = read(args)
+      observer = if reader
+                   Observed::Default::Observer.new.configure(tag: tag, reader: reader, system: system)
+                 else
+                   via = args[:via] || args[:using] ||
+                       fail(RuntimeError, %Q|Missing observer plugin name for the tag "#{tag}" in "#{args}"|)
+                   with = args[:with] || args[:which] || {}
+                   plugin = observer_plugins[via] ||
+                       fail(RuntimeError, %Q|The observer plugin named "#{via}" is not found in "#{observer_plugins}"|)
+                   plugin.new(({logger: @logger}).merge(with).merge(tag: tag, system: system))
+                 end
+      observers << observer
+      observer
+    end
+
+    def write(args)
+      to = args[:to]
+      with = args[:with] || args[:which]
+      writer = case to
+               when String
+                 plugin = writer_plugins[to] ||
+                     fail(RuntimeError, %Q|The writer plugin named "#{to}" is not found in "#{writer_plugins}"|)
+                 with = ({logger: @logger}).merge(with)
+                 plugin.new(with)
+               when Observed::Writer
+                 to
+               when nil
+                 nil
+               else
+                 fail "Unexpected type of value for the key :to in: #{args}"
+               end
+      writers << writer if writer
+      writer
+    end
+
+    def read(args)
+      from = args[:from]
+      with = args[:with] || [:which]
+      reader = case from
+               when String
+                 plugin = reader_plugins[from] || fail(RuntimeError, %Q|The reader plugin named "#{from}" is not found in "#{reader_plugins}"|)
+                 with = ({logger: @logger}).merge(with)
+                 plugin.new(with)
+               when Observed::Reader
+                 from
+               when nil
+                 nil
+               else
+                 fail "Unexpected type of value for the key :from in: #{args}"
+               end
+      readers << reader if reader
+      reader
+    end
+
+    def writers
+      @writers ||= []
+    end
+
+    def readers
+      @readers ||= []
+    end
+
+    def reporters
+      @reporters ||= []
+    end
+
+    def observers
+      @observers ||= []
+    end
+  end
+
+end

data/lib/observed/config_dsl.rb

@@ -0,0 +1,77 @@
+require 'observed/observer'
+require 'observed/configurable'
+require 'forwardable'
+require 'logger'
+
+module Observed
+  # The DSL to describe Observed's configuration.
+  # @example
+  # context = ConfigDSL.new(builder: the_builder)
+  # context.eval_file observed_conf_file(a.k.a user code describes Observed configuration)
+  # context.config #=> can be used to instantiate Observed::System
+  class ConfigDSL
+
+    extend Forwardable
+
+    include Observed::Configurable
+
+    def_delegators :@builder, :observe, :report, :read, :write
+
+    attribute :builder
+
+    def initialize(args)
+      args[:builder] || fail("The key :builder must exist in #{args}")
+      @builder = args[:builder]
+
+      @logger = args[:logger] if args[:logger]
+
+      configure(args)
+    end
+
+    def eval_file(file)
+      @file = File.expand_path(file)
+      working_directory File.dirname(@file)
+      logger.debug "Reading the file: #{@file}"
+      code = File.read(@file)
+      logger.debug "Evaluating: #{code}"
+      instance_eval(code, @file)
+    end
+
+    # The `current directory` in which `require_relative` finds source files
+    def working_directory(wd=nil)
+      @working_directory = wd if wd
+      @working_directory
+    end
+
+    # The replacement for Ruby's built-in `require_relative`.
+    # Although the built-in one can not be used in `eval` or `instance_eval` or etc because
+    # there is no `current file` semantics in `eval`, this replacement takes the file which is going to be evaluated
+    # as the `current file`.
+    # Thanks to this method, we can use `require_relative` in observed.conf files both when it is evaluated with `eval`
+    # and when it is evaluated in result of `require`.
+    def require_relative(lib)
+      path = File.expand_path("#{working_directory}/#{lib}")
+      logger.debug "Require '#{path}'"
+      require path
+    end
+
+    # Build and returns the Observed configuration
+    # @return [Observed::Config]
+    def config
+      @builder.build
+    end
+
+    # Load the file and evaluate the containing code in context of this object(a.k.a DSL).
+    # @param [String|Pathname] file The path to Ruby script containing the code in Observed's configuration DSL,
+    # typically `observed.conf`.
+    def load!(file)
+      eval_file file
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end
+end

data/lib/observed/configurable.rb

@@ -0,0 +1,56 @@
+module Observed
+  module Configurable
+
+    def initialize(args={})
+      configure(args)
+    end
+
+    def configure(args={})
+      if @attributes
+        @attributes.merge! args
+      else
+        @attributes ||= args.dup
+      end
+      self
+    end
+
+    module ClassMethods
+      # @param [String|Symbol] name
+      def attribute(name, options={})
+        define_method(name) do
+          instance_variable_get("@#{name.to_s}") || @attributes[name] || self.class.defaults[name] || fail_for_not_configured_parameter(name)
+        end
+        default_value =  options && options[:default]
+        default name => default_value if default_value
+      end
+
+      def default(args)
+        @defaults = defaults.merge(args)
+      end
+
+      def defaults
+        @defaults ||= {}
+      end
+
+      def create(args)
+        self.new(args)
+      end
+
+    end
+
+    class NotConfiguredError < RuntimeError; end
+
+    class << self
+      def included(klass)
+        klass.extend ClassMethods
+      end
+    end
+
+    private
+
+    def fail_for_not_configured_parameter(name)
+      fail NotConfiguredError.new("The parameter `#{name}` is not configured. attributes=#{@attributes}, defaults=#{self.class.defaults}")
+    end
+
+  end
+end

data/lib/observed/default/observer.rb

@@ -0,0 +1,16 @@
+require 'observed/observer'
+
+module Observed
+  module Default
+    class Observer < Observed::Observer
+
+      attribute :reader
+
+      def observe
+        data = reader.read
+        system.report(tag, data)
+      end
+
+    end
+  end
+end