observed 0.1.1 → 0.2.0.rc1

data/plugins/observed-gauge/spec/gauge_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 require 'observed/gauge'
+require 'observed/system'
 
 shared_examples_for 'the observed-gauge plugin' do
 
@@ -20,14 +21,13 @@ shared_examples_for 'the observed-gauge plugin' do
 
   it 'reports data with averaged values' do
     subject.prepare_rrd(start: t - 120, rrd: rrd)
-    system.expects(:report).with(tag, expected_data.freeze).once
-    expect { subject.report('test.foo', t - 120, data) }.to_not raise_error
-    expect { subject.report('test.foo', t - 60, data) }.to_not raise_error
-    expect { subject.report('test.foo', t, data) }.to_not raise_error
+    expect(subject.translate(data, {tag: 'test.foo', time: t - 120})).to be_nil
+    expect(subject.translate(data, {tag: 'test.foo', time: t - 60})).to be_nil
+    expect(subject.translate(data, {tag: 'test.foo', time: t})).to eq(expected_data)
   end
 
   it 'creates rrd files automatically on first report' do
-    expect { subject.report('test.foo', t, data) }.to_not raise_error
+    expect { subject.translate(data, {tag: 'test.foo', time: t}) }.to_not raise_error
 
     expect { File.exist? rrd }.to be_true
   end
@@ -64,7 +64,7 @@ describe Observed::Plugins::Gauge do
     }
 
     let(:system) {
-      sys = mock('system')
+      sys = Observed::System.new
 
       sys.stubs(:now).returns(t)
 
@@ -117,7 +117,7 @@ describe Observed::Plugins::Gauge do
       }
 
       it 'raise an error' do
-        expect { subject.report('test.foo', t, data) }.to raise_error(/Unexpected type of key_path met/)
+        expect { subject.translate(data, {tag: 'test.foo', time: t}) }.to raise_error(/Unexpected type of key_path met/)
       end
     end
 

data/plugins/observed-growl/Gemfile

@@ -0,0 +1,6 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gem 'observed', :path => "../.."
+gem 'jsonpath'
+gem 'ruby_gntp'

data/plugins/observed-growl/lib/observed/growl.rb

@@ -0,0 +1,80 @@
+require 'jsonpath'
+require 'ruby_gntp'
+
+require 'observed/reporter'
+
+module Observed
+  module Plugins
+  end
+end
+
+class Observed::Plugins::GrowlReporter < Observed::Reporter
+  plugin_name 'growl'
+
+  attribute :app_name
+  attribute :title
+  attribute :text
+  attribute :icon
+  attribute :app_name_path
+  attribute :title_path
+  attribute :text_path
+  attribute :icon_path
+  attribute :app_name_key, default: :app_name
+  attribute :title_key, default: :title
+  attribute :text_key, default: :text
+  attribute :icon_key, default: :icon
+
+  def report(data, options)
+    fetch_by_key = Fetcher.new(self, data)
+    fetch_by_path = JSONPathFetcher.new(self, data)
+    GNTP.notify({
+      :app_name => fetch_by_path[:app_name_path] || fetch_by_key[app_name_key] || '`app_name` not configured for observed-growl',
+      :title    => fetch_by_path[:title_path] || fetch_by_key[title_key] || '`title` not configured for observed-growl',
+      :text     => fetch_by_path[:text_path] || fetch_by_key[text_key] || '`text` not configured for observed-growl',
+      :icon     => fetch_by_path[:icon_path] || fetch_by_key[icon_key] || ''
+    })
+    data
+  end
+
+  class JSONPathFetcher
+    def initialize(reporter, data)
+      @reporter = reporter
+      @data = data
+    end
+    def [](name)
+      path = @reporter.get_attribute_value(name)
+      if path
+        JsonPath.on(@data, path)
+      end
+    end
+  end
+
+  class Fetcher
+    def initialize(reporter, data)
+      @reporter = reporter
+      @data = data
+    end
+    def [](name)
+      @data[name] || @reporter.get_attribute_value(name)
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'observed'
+
+  include Observed
+
+  class TestObserver < Observed::Observer
+    plugin_name 'test'
+  
+    def observe
+      {foo: 'foo from observer', 'bar' => { 'baz' => 'bar.baz from observer' } }
+    end
+  end
+
+  test = (observe via: 'test')
+    .then(report via: 'growl', with: { text_key: :foo, title_path: 'bar.baz' })
+
+  test.now
+end

data/plugins/observed-http/lib/observed/http/version.rb

@@ -1,5 +1,5 @@
 module Observed
   module Http
-    VERSION = "0.1.0"
+    VERSION = "0.2.0.rc1"
   end
 end

data/plugins/observed-http/lib/observed/http.rb

@@ -1,5 +1,7 @@
 require 'observed/http/version'
+require 'observed/observer'
 require 'observed/observer_helpers/timer'
+require 'observed/logging'
 require 'timeout'
 require 'net/http'
 
@@ -8,18 +10,22 @@ module Observed
     class HTTP < Observed::Observer
 
       include Observed::ObserverHelpers::Timer
+      include Observed::Logging
 
       attribute :timeout_in_milliseconds, default: 5000
 
       attribute :method
       attribute :url
+      attribute :logger
 
       def observe
-        logger.debug "method: #{method}, url: #{url}"
+        method = get_attribute_value(:method)
+
+        log_debug "method: #{method}, url: #{url}"
 
         uri = URI.parse(url)
 
-        logger.debug "uri: #{uri}, uri.host: #{uri.host}, uri.port:#{uri.port}, uri.path: #{uri.path}"
+        log_debug "uri: #{uri}, uri.host: #{uri.host}, uri.port:#{uri.port}, uri.path: #{uri.path}"
 
         http_method = method.capitalize
         path = if uri.path.size == 0
@@ -36,23 +42,19 @@ module Observed
 
         time_and_report(tag: self.tag, timeout_in_seconds: timeout_in_seconds) do
 
-          logger.debug "Sending a HTTP request with the timeout of #{timeout_in_seconds} seconds"
+          log_debug "Sending a HTTP request with the timeout of #{timeout_in_seconds} seconds"
 
           body = Net::HTTP.start(uri.host, uri.port) {|http|
             http.request(req)
           }.body
 
-          logger.debug "Response body: #{body}"
+          log_debug "Response body: #{body}"
 
           "#{http_method} #{uri}"
         end
 
       end
 
-      def logger
-        @logger ||= Logger.new(STDOUT)
-      end
-
       plugin_name 'http'
 
     end

data/plugins/observed-http/observed-http.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "observed", "~> 0.1.0"
+  spec.add_dependency "observed", "~> 0.2.0.rc1"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/plugins/observed-http/spec/http_spec.rb

@@ -1,14 +1,69 @@
 require 'spec_helper'
 
-require 'observed/application/oneshot'
+require 'observed/http'
+
+describe Observed::Plugins::HTTP do
 
-describe Observed::Application::Oneshot do
   subject {
-    Observed::Application::Oneshot.create(
-        config_file: 'spec/fixtures/observed.conf'
-    )
+    Observed::Plugins::HTTP.new
+  }
+
+  before {
+    subject.configure config
+  }
+
+  let(:config) {
+    {
+        timeout_in_milliseconds: 1000,
+        method: 'get',
+        url: 'http://google.com/',
+        tag: 'test',
+        system: sys
+    }
+  }
+
+  let(:sys) {
+    sys = mock('system')
+    sys.stubs(:now).returns(before).then.returns(after)
+    sys
+  }
+
+  let(:before) {
+    Time.now
+  }
+
+  let(:after) {
+    Time.now + 1
   }
-  it 'initializes' do
-    expect(subject.run.size).not_to eq(0)
+
+  let(:response) {
+    res = stub('response')
+    res.stubs(body: 'the response body')
+    res
+  }
+
+  context 'when timed out' do
+    before {
+      Timeout.expects(:timeout).raises(Timeout::Error)
+
+      sys.expects(:report).with('test.error', {status: :error, error: {message: 'Timed out.'}, timed_out: true})
+    }
+
+    it 'reports an error' do
+      expect { subject.observe }.to_not raise_error
+    end
   end
+
+  context 'when not timed out' do
+    before {
+      Timeout.expects(:timeout).returns({ status: :success, result: 'Get http://google.com/' })
+
+      sys.expects(:report).with('test.success', {status: :success, result: 'Get http://google.com/', elapsed_time: after - before})
+    }
+
+    it 'reports an success' do
+      expect { subject.observe }.to_not raise_error
+    end
+  end
+
 end

data/plugins/observed-http/spec/integration_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+require 'observed/application/oneshot'
+
+describe Observed::Application::Oneshot do
+  subject {
+    Observed::Application::Oneshot.create(
+        config_file: 'spec/fixtures/observed.conf'
+    )
+  }
+  it 'initializes' do
+    expect(subject.run.size).not_to eq(0)
+  end
+end

data/plugins/observed-shell/Gemfile

@@ -0,0 +1,5 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gem 'observed', :path => '../..'
+gem 'mixlib-shellout'

data/plugins/observed-shell/lib/observed/shell.rb

@@ -0,0 +1,54 @@
+require 'mixlib/shellout'
+
+require 'observed/observer'
+require 'observed/reporter'
+
+module Observed
+  module Plugins
+  end
+end
+
+class Observed::Plugins::ShellObserver < Observed::Observer
+  plugin_name 'shell'
+
+  attribute :command
+
+  def observe
+    c = Mixlib::ShellOut.new(*command)
+    c.run_command
+    { command: command, stdout: c.stdout, stderr: c.stderr }
+  end
+end
+
+class Observed::Plugins::ShellReporter < Observed::Reporter
+  plugin_name 'shell'
+
+  attribute :command
+  attribute :input_key
+
+  def report(data, options)
+    if command.is_a? Proc
+      num_params = command.parameters.size
+      args = [data, options].take(num_params)
+      result = command.call *args
+      command_line = result
+    else
+      command_line = command
+    end
+    c = Mixlib::ShellOut.new(*command_line, input: data[get_attribute_value(:input_key)])
+    c.run_command
+    #logger.debug %Q|[observed-shell] ShellReporter executed the command "#{command_line}", captured stdout is "#{c.stdout}", captured stderr is #{c.stderr}"|
+    data
+  end
+end
+
+if __FILE__ == $0
+  require 'observed'
+  
+  include Observed
+
+  test = (observe via: 'shell', with: { command: 'echo foo' } )
+    .then(report via: 'shell', with: { command: -> d { "growlnotify -m #{d[:stdout]}" } } )
+  
+  test.now
+end

data/run-integration-tests

@@ -0,0 +1,81 @@
+#!/bin/bash --login
+
+# '--login' is needed to deal with the following warning otherwise emitted by rvm:
+#   You need to change your terminal emulator preferences to allow login shell.
+#   Sometimes it is required to use `/bin/bash --login` as the command.
+#   Please visit https://rvm.io/integration/gnome-terminal/ for a example.
+
+rvm gemset create observed-test
+rvm gemset use observed-test
+
+observed_dir=`dirname $0`
+
+cd $observed_dir
+
+observed_dir=`pwd`
+
+plugins_dir=$observed_dir/plugins
+integrations_dir=$observed_dir/integrations
+integrations="clockwork eventmachine"
+plugins="http fluentd gauge"
+
+#cd $observed_dir
+
+dirs=$observed_dir
+
+for integration in $integrations
+do
+  dirs="$dirs $integrations_dir/observed-$integration"
+done
+
+for plugin in $plugins
+do
+  dirs="$dirs $plugins_dir/observed-$plugin"
+done
+
+echo $dirs
+
+function quit_on_failure {
+  if [[ $? -ne 0 ]]; then
+    quit 1
+  fi
+}
+
+function quit {
+  rvm --force gemset delete observed-test
+  if [[ $1 == "" ]]; then
+    exit 0
+  fi
+  exit $1
+}
+
+for target in $dirs
+do
+  echo Target: $target
+  cd $target
+  echo Current directory: `pwd`
+  export BUNDLE_GEMFILE=$target/Gemfile
+  bundle install
+  if [[ $? -ne 0 ]]; then
+    bundle update
+  fi
+  if [ -d spec ]
+  then
+    bundle exec rspec
+  fi
+  quit_on_failure
+
+  if [ -d features ]
+  then
+    bundle exec cucumber
+  fi
+  quit_on_failure
+
+  rake install
+  if [[ $? -ne 0 ]]; then
+    gem install pkg/*.gem
+  fi
+
+done
+
+quit

data/spec/builtin_plugins/stdout_spec.rb

@@ -11,7 +11,11 @@ describe Observed::BuiltinPlugins::Stdout do
   }
 
   let(:config) {
-    { tag_pattern: /foo\..+/, format: formatter }
+    { tag_pattern: /foo\..+/, format: formatter, output: output }
+  }
+
+  let(:output) {
+    mock('output')
   }
 
   context 'with a specific formatter' do
@@ -22,7 +26,7 @@ describe Observed::BuiltinPlugins::Stdout do
 
     it 'reports the formatted data to the stdout' do
       time = Time.now
-      STDOUT.expects(:puts).with("foo #{time.to_i} 1 2")
+      output.expects(:puts).with("foo #{time.to_i} 1 2")
       expect { subject.report('foo', time, {foo: 1, bar: {baz: 2}}) }.to_not raise_error
     end
 
@@ -36,7 +40,7 @@ describe Observed::BuiltinPlugins::Stdout do
 
     it 'reports the data formatted by the default formatter to the stdout' do
       time = Time.now
-      STDOUT.expects(:puts).with("#{time.to_s} foo {:foo=>1}")
+      output.expects(:puts).with("#{time.to_s} foo {:foo=>1}")
       expect { subject.report('foo', time, {foo: 1}) }.to_not raise_error
     end
 

data/spec/config_builder_spec.rb

@@ -7,14 +7,18 @@ describe Observed::ConfigBuilder do
 
   subject {
     Observed::ConfigBuilder.new(
-        writer_plugins: writer_plugins,
-        reader_plugins: reader_plugins,
+        context: context,
         observer_plugins: observer_plugins,
         reporter_plugins: reporter_plugins,
+        translator_plugins: translator_plugins,
         system: system
     )
   }
 
+  let(:context) {
+    Observed::Context.new
+  }
+
   let(:system) {
     mock('system')
   }
@@ -27,7 +31,7 @@ describe Observed::ConfigBuilder do
         content = File.open(path, 'r') do |f|
           f.read
         end
-        system.report(tag, { key => content })
+        { key => content }
       end
     end
     { 'my_file' => my_file }
@@ -58,54 +62,21 @@ describe Observed::ConfigBuilder do
     { 'stdout' => stdout }
   }
 
-  let(:reader_plugins) {
-    file = Class.new(Observed::Reader) do
-      attribute :path
-      attribute :key
-      def read
-        content = File.open(path, 'r') do |f|
-          f.read
-        end
-        { key => content }
+  let(:translator_plugins) {
+    my_translator = Class.new(Observed::Translator) do
+      attribute :tag
+      attribute :format
+      def translate(tag, time, data)
+        formatted_data = format.call tag, time, data, Observed::Hash::Fetcher.new(data), Observed::Hash::Builder.new
+        {formatted:formatted_data}
       end
+      plugin_name 'my_translator'
     end
     {
-        'file' => file
+        'my_translator' => my_translator
     }
   }
 
-  it 'creates writers' do
-    time = Time.now
-    subject.write to: 'stdout', with: {
-      format: -> tag, time, data, d { "value:#{d['foo.bar']}" }
-    }
-    STDOUT.expects(:puts).with('value:123')
-    expect { subject.build.writers.first.write('foo.bar', time, {foo:{bar:123}}) }.to_not raise_error
-  end
-
-  it 'creates readers' do
-    subject.read from: 'file', with: {
-      path: 'foo.txt',
-      key: 'content'
-    }
-    File.open('foo.txt', 'w') do |f|
-      f.write('file content')
-    end
-    expect(subject.build.readers.first.read).to eq({ 'content' => 'file content' })
-  end
-
-  it 'creates observers from reader plugins' do
-    subject.observe 'foo.bar', from: 'file', with: {
-      path: 'foo.txt',
-      key: 'content'
-    }
-    File.open('foo.txt', 'w') do |f|
-      f.write('file content')
-    end
-    system.expects(:report).with('foo.bar', { 'content' => 'file content' })
-    expect { subject.build.observers.first.observe }.to_not raise_error
-  end
-
   it 'creates observers from observer plugins' do
     subject.observe 'foo.bar', via: 'my_file', which: {
         path: 'foo.txt',
@@ -114,22 +85,20 @@ describe Observed::ConfigBuilder do
     File.open('foo.txt', 'w') do |f|
       f.write('file content')
     end
-    system.expects(:report).with('foo.bar', { 'content' => 'file content' })
-    expect { subject.build.observers.first.observe }.to_not raise_error
+    the_data = nil
+    subject.build.observers.first.now do |data, options|
+      the_data = data
+    end
+    expect(the_data).to eq({'content' => 'file content'})
   end
 
-  it 'creates reporters from writer plugins' do
-    tag = 'foo.bar'
-    time = Time.now
-
-    subject.report /foo\.bar/, to: 'stdout', with: {
-      format: -> tag, time, data, d { "foo.bar #{time} #{d[tag]}" }
-    }
-    reporter = subject.reporters.first
-    STDOUT.expects(:puts).with("foo.bar #{time} 123").once
-    expect(reporter.match(tag)).to be_true
-    expect { reporter.report(tag, time, { foo: { bar: 123 }}) }.to_not raise_error
-  end
+  #it 'creates default observers from poller plugins' do
+  #  subject.observe 'foo.bar', via: 'poll', which: {
+  #      result: 'result'
+  #  }
+  #  system.expects(:report).with('foo.bar', { 'content' => 'file content' })
+  #  expect { subject.build.pollers.first.poll }.to_not raise_error
+  #end
 
   it 'creates reporters from reporter plugins' do
     tag = 'foo.bar'
@@ -143,4 +112,18 @@ describe Observed::ConfigBuilder do
     expect(reporter.match(tag)).to be_true
     expect { reporter.report(tag, time, { foo: { bar: 123 }}) }.to_not raise_error
   end
+
+  it 'creates translator from translator plugins' do
+    time = Time.now
+    translator = subject.translate via: 'my_translator', with: {
+      tag: 'foo.baz',
+      format: -> tag, time, data, f, b { b['bar.baz'] = "foo.bar #{time} #{f[tag]}"; b.build }
+    }
+
+    result = {bar:{baz:"foo.bar #{time} 123"}}
+
+    translator.now({foo:{bar: 123}}, {tag: 'foo.bar', time: time}) do |data, options|
+      expect(data).to eq({formatted: result})
+    end
+  end
 end

data/spec/config_dsl_spec.rb

@@ -8,11 +8,15 @@ require 'observed/config_builder'
 describe Observed::ConfigDSL do
   subject {
     Observed::ConfigDSL.new(builder: Observed::ConfigBuilder.new(
+        context: context,
         observer_plugins: observer_plugins,
         reporter_plugins: reporter_plugins,
         system: sys
     ))
   }
+  let(:context) {
+    Observed::Context.new
+  }
   let(:foo) {
     Class.new(Observed::Observer) do
       def observe