observed 0.1.1 → 0.2.0.rc1

data/lib/observed/context.rb

@@ -0,0 +1,90 @@
+require 'logger'
+
+require 'observed/system'
+require 'observed/config_builder'
+require 'observed/config_dsl'
+require 'observed/job'
+require 'observed/jobbed_event_bus'
+
+module Observed
+  # The run context of an Observed system.
+  # It can be initialized via parameters to automatically configure the system and everything needed such as the config
+  # builder, the DSL, the logger, etc.
+  class Context
+
+    def initialize(args={})
+      configure args
+    end
+
+    def configure(args)
+      @logger ||= begin
+        logger_out = if args[:log_file]
+                       File.open(args[:log_file], 'a')
+                     else
+                       STDOUT
+                     end
+        Logger.new(logger_out)
+      end
+
+      @executor = args[:executor]
+
+      set_log_level_to_debug(!!args[:debug])
+
+      if args[:config_file]
+        load_config_file(args[:config_file])
+      end
+
+      self
+    end
+
+    def logger
+      @logger
+    end
+
+    def system
+      @system ||= Observed::System.new(logger: logger, context: self)
+    end
+
+    def executor
+      @executor ||= Observed::BlockingJobExecutor.new
+    end
+
+    def jobbed_event_bus
+      @event_bus ||= Observed::JobbedEventBus.new(job_factory: job_factory)
+    end
+
+    def job_factory
+      @job_factory ||= Observed::JobFactory.new(executor: executor)
+    end
+
+    def execution_job_factory
+      @execution_job_factory ||= Observed::ExecutionJobFactory.new(job_factory: job_factory)
+    end
+
+    def config_builder
+      @config_builder ||= Observed::ConfigBuilder.new(system: system, logger: logger, context: self)
+    end
+
+    def config_dsl
+      Observed::ConfigDSL.new(builder: config_builder, logger: logger)
+    end
+
+    private
+
+    def set_log_level_to_debug(enabled)
+      @logger.level = if enabled
+                        Logger::DEBUG
+                      else
+                        Logger::INFO
+                      end
+
+      @logger.debug "Enabling Debug logs." if enabled
+    end
+
+    def load_config_file(path)
+      config_dsl.eval_file(path)
+      system.config = config_dsl.config
+    end
+
+  end
+end

data/lib/observed/default/observer.rb

@@ -4,11 +4,8 @@ module Observed
   module Default
     class Observer < Observed::Observer
 
-      attribute :reader
-
-      def observe
-        data = reader.read
-        system.report(tag, data)
+      def observe(data)
+        [tag, data]
       end
 
     end

data/lib/observed/default.rb

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

data/lib/observed/event_bus.rb

@@ -0,0 +1,31 @@
+require 'thread'
+
+module Observed
+  class EventBus
+    def initialize
+      @mutex = ::Mutex.new
+      @subscribers = []
+    end
+    def emit(tag, *params)
+      handle_event(tag, *params)
+    end
+
+    def on_receive(pattern, &block)
+      @mutex.synchronize do
+        @subscribers.push [pattern, block]
+      end
+    end
+
+    private
+
+    def handle_event(tag, *params)
+      @mutex.synchronize do
+        @subscribers.each do |pattern, s|
+          if pattern.match(tag)
+            s.call *params
+          end
+        end
+      end
+    end
+  end
+end

data/lib/observed/execution_job_factory.rb

@@ -0,0 +1,95 @@
+require 'observed/observer'
+require 'observed/reporter'
+require 'observed/translator'
+require 'observed/job'
+
+module Observed
+  # An yet another cushion from the deprecated plugin interface to the new plugin interface
+  class FakeSystem
+
+    def initialize(args)
+      @time = args[:time] || Time.now
+    end
+
+    def report(tag, time, data=nil)
+      options = nil
+      if tag.is_a?(::Hash)
+        data = tag
+        options = time || {}
+        tag = nil
+      elsif tag.is_a?(String) && time.is_a?(::Hash)
+        options = data
+        data = time
+      else
+        options = {tag: tag, time: time}
+      end
+      options ||= {}
+      options[:tag] ||= tag
+      options[:time] ||= now
+      @reported = [data, options]
+    end
+
+    def reported
+      @reported
+    end
+
+    def now
+      @time
+    end
+  end
+
+  class ExecutionJobFactory
+
+    def initialize(args={})
+      @job_factory = args[:job_factory] || Observed::JobFactory.new(executor: Observed::BlockingJobExecutor.new)
+    end
+
+    # Convert the observer/translator/reporter to a job
+    def convert_to_job(underlying)
+      if underlying.is_a? Observed::Observer
+        @job_factory.job {|data, options|
+          options ||= {}
+          m = underlying.method(:observe)
+          fake_system = FakeSystem.new(time: options[:time])
+          # For 0.1.0 compatibility
+          underlying.configure(system: fake_system)
+          underlying.configure(tag: options[:tag]) unless underlying.get_attribute_value(:tag)
+          result = dispatch_method m, data, options
+          fake_system.reported || result
+        }
+      elsif underlying.is_a? Observed::Reporter
+        @job_factory.job {|data, options|
+          options ||= {}
+          m = underlying.method(:report)
+          dispatch_method m, data, options
+        }
+      elsif underlying.is_a? Observed::Translator
+        @job_factory.job {|data, options|
+          options ||= {}
+          m = underlying.method(:translate)
+          dispatch_method m, data, options
+        }
+      else
+        fail "Unexpected type of object which can not be converted to a job: #{underlying}"
+      end
+    end
+
+    def dispatch_method(m, data, options)
+      num_parameters = m.parameters.size
+      case num_parameters
+      when 0
+        m.call
+      when 1
+        m.call data
+      when 2
+        m.call data, options
+      when 3
+        # Deprecated. This is here for backward compatiblity
+        m.call options[:tag], options[:time], data
+      else
+        fail "Unexpected number of parameters for the method `#{m}`: #{num_parameters}"
+      end
+    end
+
+  end
+end

data/lib/observed/job.rb

@@ -0,0 +1,163 @@
+require 'logger'
+require 'thread'
+
+module Observed
+  class Job
+    def then(*jobs)
+      next_job = if jobs.size == 1
+                   jobs.first
+                 elsif jobs.size > 1
+                   ParallelJob.new(jobs)
+                 else
+                   raise 'No jobs to be executed'
+                 end
+      SequenceJob.new(self, next_job)
+    end
+  end
+
+  class MutableJob
+    def initialize(current_job)
+      @current_job = current_job
+      @mutex = Mutex.new
+    end
+    def now(data={}, options=nil)
+      @current_job.now(data, options) do |data, options2|
+        yield data, (options2 || options) if block_given?
+      end
+    end
+    def then(*jobs)
+      @mutex.synchronize do
+        @current_job = @current_job.then(*jobs)
+      end
+      self
+    end
+  end
+
+  class SequenceJob < Job
+    attr_reader :base_job
+    def initialize(base_job, next_job)
+      @base_job = base_job
+      @next_job = next_job
+    end
+    def now(data={}, options=nil)
+      @base_job.now(data, options) do |data, options2|
+        @next_job.now(data, (options2 || options)) do |data, options3|
+          yield data, (options3 || options2 || options) if block_given?
+        end
+      end
+    end
+  end
+
+  class ParallelJob < Job
+    def initialize(jobs)
+      @jobs = jobs || fail('jobs missing')
+      @next_job = NoOpJob.instance
+    end
+    def now(data={}, options=nil)
+      @jobs.each do |job|
+        job.now(data, options) do |data, options2|
+          yield data, (options2 || options) if block_given?
+        end
+      end
+    end
+  end
+
+  class NoOpJob < Job
+    def now(data={}, options={}); end
+    def self.instance
+      SINGLETON_INSTANCE
+    end
+    SINGLETON_INSTANCE = NoOpJob.new
+  end
+
+  class ProcJob < Job
+    def initialize(args, &block)
+      @executor = args[:executor] || fail('Missing a value for :executor')
+      @listener = args[:listener] || fail('Missing a value for :listener')
+      @logger = args[:logger]
+      @block = block
+      @next_job = NoOpJob.instance
+
+      if @logger.nil?
+        @logger = ::Logger.new(STDERR)
+        @logger.level = ::Logger::WARN
+      end
+    end
+    def now(data={}, options=nil)
+      @executor.execute {
+        result = @block.call(data, options)
+        yield result if block_given?
+        notify_listener(data: data, options: options, result: result)
+      }
+    end
+
+    private
+
+    def notify_listener(args)
+      return unless @listener
+
+      data = args[:data]
+      options = args[:options]
+      result = args[:result]
+
+      @logger.debug "Notifying listeners with the result(#{result}) generated from the input data(#{data}) and the options(#{options})"
+
+      if result.is_a? ::Hash
+        if options
+          @listener.on_result(result, options)
+        else
+          @listener.on_result(result)
+        end
+      elsif result.is_a? ::Array
+        if result.size == 1 && options
+          @listener.on_result(result, options)
+        elsif result.size == 2
+          @listener.on_result(*result)
+        end
+      end
+    end
+  end
+
+  class JobListener
+    def on_result(data={}, options={})
+
+    end
+  end
+
+  class JobFactory
+    def initialize(args)
+      @executor = args[:executor] || fail('Missing a value for :executor')
+      @listener = args[:listener] || JobListener.new
+    end
+
+    def job(&block)
+      ProcJob.new(executor: @executor, listener: @listener, &block)
+    end
+
+    def mutable_job(&block)
+      MutableJob.new(job(&block))
+    end
+
+    def parallel(jobs)
+      ParallelJob.new(jobs)
+    end
+  end
+
+  class JobExecutor
+    def execute; end
+  end
+
+  class BlockingJobExecutor
+    def execute
+      yield
+    end
+  end
+
+  class ThreadedJobExecutor
+    def execute
+      Thread.start {
+        yield
+      }
+    end
+  end
+end

data/lib/observed/jobbed_event_bus.rb

@@ -0,0 +1,33 @@
+require 'thread'
+require 'observed/event_bus'
+
+module Observed
+  class JobbedEventBus
+    def initialize(args={})
+      @bus = Observed::EventBus.new
+      @receives = {}
+      @job_factory = args[:job_factory] || fail("The parameter :job_factory is missing in args(#{args}")
+      @mutex = ::Mutex.new
+    end
+    def pipe_to_emit(tag)
+      @job_factory.job { |*params|
+        self.emit(tag, *params)
+        params
+      }
+    end
+    def emit(tag, *params)
+      @bus.emit tag, *params
+    end
+    def receive(pattern)
+      job = @job_factory.mutable_job {|data, options|
+        [data, options]
+      }
+      @bus.on_receive(pattern) do |*params|
+        @mutex.synchronize do
+          job.now(*params)
+        end
+      end
+      job
+    end
+  end
+end

data/lib/observed/logging.rb

@@ -0,0 +1,40 @@
+require 'observed/configurable'
+
+module Observed
+  module Logging
+    include Observed::Configurable
+
+    # !@attribute [r] logger
+    #  @return [Logger]
+    attribute :logger
+
+    # @return [Boolean] `true` if a value is set for the attribute :logger
+    def logging_enabled?
+      has_attribute_value? :logger
+    end
+
+    # Log the debug message through the logger configured via the :logger attribute
+    # @param [String] message
+    def log_debug(message)
+      logger.debug message if logging_enabled?
+    end
+
+    # Log the info message through the logger configured via the :logger attribute
+    # @param [String] message
+    def log_info(message)
+      logger.info message if logging_enabled?
+    end
+
+    # Log the warn message through the logger configured via the :logger attribute
+    # @param [String] message
+    def log_warn(message)
+      logger.warn message if logging_enabled?
+    end
+
+    # Log the error message through the logger configured via the :logger attribute
+    # @param [String] message
+    def log_error(message)
+      logger.error message if logging_enabled?
+    end
+  end
+end

data/lib/observed/observer.rb

@@ -1,5 +1,6 @@
 require 'observed/configurable'
 require 'observed/pluggable'
+require 'observed/logging'
 
 module Observed
 

data/lib/observed/observer_helpers/timer.rb

@@ -17,10 +17,12 @@ module Observed
           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}"} }
+        rescue Timeout::Error => e
+          log_debug "Handled the error but logging it just for your info: #{e.message}\n#{e.backtrace.join("\n")}" if self.is_a? Logging
+          { status: :error, error: {message: 'Timed out.'}, timed_out: true }
+        rescue => e
+          log_error "Handled the error: #{e.message}\n#{e.backtrace.join("\n")}" if self.is_a? Logging
+          { status: :error, error: {message: e.message} }
         end
       end
 
@@ -29,7 +31,13 @@ module Observed
         format = options[:format] || ->(r){ r }
         result = time(options, &block)
 
-        system.report("#{tag}.#{result[:status]}", format.call(result))
+        data = ["#{tag}.#{result[:status]}", format.call(result)]
+
+        if self.method(:observe).parameters.size != 1
+          system.report(*data)
+        end
+
+        data
       end
 
     end

data/lib/observed/pluggable.rb

@@ -1,4 +1,14 @@
 module Observed
+  # Indicates that the class is pluggable (or extensible or a extension point).
+  # "pluggable" means that the class included this module will be the outlet in where Observed plug-ins are plugged.
+  #
+  # @example
+  # class Reader
+  #   include Pluggable
+  # end
+  # class FooReader < Reader; end
+  # class BarReader < Reader; end
+  # Reader.plugins #=> [FooReader, BarReader]
   module Pluggable
 
     module ClassMethods
@@ -7,6 +17,7 @@ module Observed
       end
 
       def inherited(klass)
+        super if defined? super
         plugins << klass
       end
 

data/lib/observed/reporter/regexp_matching.rb

@@ -3,7 +3,8 @@ module Observed
     module RegexpMatching
 
       def match(tag)
-        tag_pattern.match(tag)
+        tag_pattern = get_attribute_value(:tag_pattern)
+        tag_pattern.match(tag) if tag_pattern
       end
 
     end

data/lib/observed/reporter/report_formatting.rb

@@ -0,0 +1,57 @@
+require 'observed/configurable'
+require 'observed/hash/fetcher'
+
+module Observed
+  class Reporter
+    # The module to equip an observer with a `formatter` to format the data being reported.
+    # The `formatter` is just a proc and is able to be configured via an attribute.
+    #
+    # @example
+    # class YourObserver < Observed::Reporter
+    #   include Observed::Reporter::Configurable
+    #   include Observed::Reporter::ReportFormatting
+    #
+    #   attribute :format, default: -> tag, time, data { "#{Time.at(time)} #{tag} #{data}" }
+    #
+    #   def report(tag, time, data)
+    #     formatted_data = format_report(tag, time, data)
+    #     # The output of your choice
+    #   end
+    # end
+    #
+    # observer = YourObserver.new(format: -> tag, time, data { "The data being reported: #{tag} #{time} #{data}" })
+    # observer.report('test', Time.now, {data: 1})
+    # #=> outputs "#{Time.at(Time.now)} test {:data=>1}"
+    module ReportFormatting
+
+      include Observed::Configurable
+
+      attribute :format, default: -> tag, time, data {
+        begin
+          "#{Time.at(time)} #{tag} #{data}"
+        rescue => e
+          nested = Exception.new("Error while formatting the data: tag=#{tag} time=#{time} data=#{data} " + e.message)
+          nested.set_backtrace(e.backtrace)
+          raise nested
+        end
+      }
+
+      # Format the data being reported. The data includes 3 parameters: `tag`, `time` and `data`.
+      # @param [String] tag
+      # @param [Time] time
+      # @param [Hash] data
+      def format_report(tag, time, data)
+        num_params = format.parameters.size
+        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
+      end
+
+    end
+  end
+end

data/lib/observed/reporter.rb

@@ -10,8 +10,6 @@ module Observed
     #   @return [Regexp]
     attribute :tag_pattern
 
-    attribute :system
-
     # @param [String] tag
     def match(tag)
       raise NotImplementedError.new