observed 0.1.1 → 0.2.0.rc1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjY4MTNiYmFjYTdiNmQ3ODk3ZThkOGRjMjNkNWI1MDg2MmZhYTUxNw==
+    ZjAzODY3YWFkYmE3ZWM3MGFmYzkzY2Y4ZjI4MTExNmQyYjRmZTJjOQ==
   data.tar.gz: !binary |-
-    YzYwZWI3NGE3ZmI4MmQ4NDRkZWZkMTBiNzU2NDM5NmUzMzg3ZWZiYQ==
-!binary "U0hBNTEy":
+    YzdlNTAyYWNmNzZmNWNlODNmYTA0MDY4ZjFjM2RlMWFlNTFhNjFlMw==
+SHA512:
   metadata.gz: !binary |-
-    NGM5N2Q4ODQzMTRlZDMzNzdiN2UwODVjNmE0NzUwMjdkZTU2MzdkOThjNjc3
-    NmQwMjRkZGIzYzM0ZDA3N2FkMWVkZmY0YjAyNDE3MWNjMjMxMDUwYmY5ZmMw
-    MWNkMjFmN2RiMTY2Mzg1MjRmMzVlOWEwMGM0MDAxZjE5N2UyOTg=
+    Y2UzMWZiYjliOGE0MDRiMGVhZTE1ZGExOWQzNzBjYjU5YzM4MDM3OWE0MWRh
+    OWJjYWRlNDc5YjhjMGRmNTY1NGI0Yzg0MWMxY2Q1NjdjZjA1MGZjNjYzODU0
+    MDA1ZGM4MjE5MDQzYTMxNWYwNjExYzYzMmUyOTFkYzBjNzFlYTM=
   data.tar.gz: !binary |-
-    MTYxNDc0NGRlZjE2NDkwMzNmOGY5ZTM4MDQ1NmNkZWJkNTY0NDk0MWY4MDkz
-    OWQ2ZjQ1MzVhYTQyNDE2MGU4YjExZDEyNTg3ZDg1ZDBmM2NlMWViMjBlZjdi
-    YzQ0MWE5OThlMDc1ZmVmMGZkMTQ5YTAxM2QxNTg4NWU4ZGIyYzQ=
+    NTZhM2U0Nzg3M2ViMjMzNDM1NTI3YTZlOTUwOWE1NDk0OGNiMGM3Y2MwNWVi
+    MGZhOTZkY2YxMzBkYzZhNWJhM2M2MmQyMWFjYzE2YWY3YTRmM2Y2ZGViYjEx
+    ZDg5YzM5YmQzZTY4MDg0NTE3YTJlNTRhNWMwNTAzOGYzYWUxNmY=

data/.travis.yml

@@ -9,3 +9,7 @@ matrix:
   exclude:
     - rvm: 1.9.3
       jdk: openjdk7
+  allow_failures:
+    - rvm: jruby-19mode
+script: ./run-integration-tests
+before_install: sudo apt-get install librrd-dev

data/README.md

@@ -1,67 +1,45 @@
-# [Observed](https://github.com/gree/observed)
+# Observed
 
-A polling framework
+[![Build Status](https://travis-ci.org/gree/observed.png?branch=master)](https://travis-ci.org/gree/observed) [![Coverage Status](https://coveralls.io/repos/gree/observed/badge.png?branch=master)](https://coveralls.io/r/gree/observed?branch=master) [![Code Climate](https://codeclimate.com/github/gree/observed.png)](https://codeclimate.com/github/gree/observed)
 
-[Observed](https://github.com/gree/observed) is a framework for polling various applications/middlewares/services running locally or on remote servers like
-ones in your production environment.
-It is designed with extensibility in mind.
+Observed is a highly extensible framework for polling applications, middlewares and services running locally or on remote servers.
 
 -----
 
-Observed polls services, optionally transforms the results, and then redirects the results to another services.
-Observed is open for extension which means that it is extensible via plugins to support add more services and transformations.
+Observed allows you to:
 
-To be clear, you can use Observed to:
+1.  poll server(s),
+2.  optionally modify the response result,
+3.  pass the result on to other services or trigger other tasks
 
-1.  poll something,
-2.  optionally transform the result,
-3.  pass the result to another services or trigger something
+All the above 3 operations are extensible via plugins and can be configured via configuration files.
 
-All the three things mentioned above can be extended via plugins and configured via configuration files.
-
-There are known plugins for:
+There are plugins available for:
 
 -  Polling HTTP-based services to detect failures and performance degradation
 -  Sending observed data to Fluentd
--  (More to come)
-
-Observed has has a very small code-base (only a few hundreds of lines) and it should not be too hard to understand the
-code and develop plugins.
 
-Observed's extensible design through plugins is inspired by other Ruby products like Fluentd,
-and having knowledge of other Ruby products may help understanding Observed.
-(But remember that Observed is yet a highly ambitioned and experimental framework. Observed's code has more space to
-improve than other great Ruby products.)
+Additional plugins will be released in the future.
 
-Observed is (and its plugins should be) stateless.
-Specially for Observed, this means that it should work similarly when it is ran as a daemon or a _oneshot_ application like
-a regular cron job as states are stored somewhere outside of the application instance.
+Observed has has a very small code-base (only a few hundred lines) which makes reading and understanding it's source code and developing plugins for it a relatively simple task.
 
-Observed is intended to work on Ruby 1.9.3 but should work on Ruby 2.0+ too.
+Observed's extensible design through plugins is inspired by other Ruby projects such as Fluentd. People familiar with other Ruby products should feel right at home with Observed. As of now it is a highly ambitious and experimental framework with big potential for growth and improvements.
 
-## What it is not
+Observed is (and its plugins should be) stateless.
+This means that it should work in the same manner whether it is run as a daemon or a _oneshot_ application like
+a regular cron job, as states should be stored outside of the application instance with regards to Observed.
 
-Observed is:
+Observed is intended to be run on Ruby 1.9.3 but should work on Ruby 2.0+ too.
 
--  Not a framework for creating Web-based polls which are voted. It's all about [polling (computer science)](http://en.wikipedia.org/wiki/Polling_\(computer_science\))
--  Not a monitoring and reporting tool like Ganglia, New Relic, or etc.
-   But Observed can be used to gather simple metrics via its plugins, and it can pass those metrics to an another tool to
-   achieve any serious monitoring or reporting.
--  Not a log collector like Fluentd.
-   Observed can be used to emit event logs to the log collector of your choice, but it does not replace or act like that.
--  Not a [job scheduler](http://en.wikipedia.org/wiki/Job_scheduler) like cron, though it can be integrated to those schedulers to make them trigger Observed to do the
-   job.
+## Observed is not:
+-  a monitoring and reporting tool such as New Relic etc. However, Observed can be used for collecting simple metrics via plugins, then pass them on to another full-fledged monitoring or reporting tool.
+-  a log collector like Fluentd. Observed can be used to emit event logs to the log collector of your choice, but it does not replace the log collector.
+-  a [job scheduler](http://en.wikipedia.org/wiki/Job_scheduler) (e.g. cron), though it can be integrated with job schedulers to make them trigger Observed to perform jobs.
 
 ## Similar products
 
-- [vacuumetrix](https://github.com/99designs/vacuumetrix) gets metrics from various sources and puts those to various
-  outputs like Graphite, Ganglia, etc.
-  On the other hand, Observed scope itself to be used just for `polling` and also it outputs to not only monitoring
-  systems but any system.
-- [metrics-sampler](https://github.com/dimovelev/metrics-sampler) is a java program which queries metrics from various
-  sources and sends them to outputs like the console or Graphite. It supports inputs such as JMX, JDBC, apache-status,
-  Oracle NoSQL, Redis, webmethods, or regular process which is runnable via the command-line and is able to communiate
-  via standard input/output.
+- [vacuumetrix](https://github.com/99designs/vacuumetrix) - Collects metrics from various sources and outputs them to various destinations (e.g Graphite). Observed only covers the `polling` part, but can output to not just monitoring systems but any system.
+- [metrics-sampler](https://github.com/dimovelev/metrics-sampler) - A Java program which queries metrics from various sources and outputs to various destinations such as Graphite or consoles. It supports various methods of input such as JMX, JDBC, apache-status, Oracle NoSQL, Redis, web API, or regular processes which are executable via the command-line, and is able to communicate via standard input/output.
 
 ## Installation
 
@@ -73,7 +51,7 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
+Or install it yourself with:
 
     $ gem install observed
 
@@ -83,24 +61,23 @@ Or `git clone` the sources and install by using rake:
 
 ## Usage
 
-Just for the purpose of illustration, _let Observed observe and report the healthiness of Google_.
+Simple example: _use Observed to observe and report the healthiness of Google_.
 
-Observed itself is just a framework and doesn't support any service by default.
-Now, just for example, let's assume that we want Observed to poll our HTTP-based webs service and report the result and
-show average response time.
-We start with installing some observed plugins:
+Assume that we want Observed to poll a HTTP-based web service (Google) and report the results.
+
+Since Observed by itself is just a framework and by default does not have built-in support for any service, we start by installing some Observed plugins:
 
     $ gem install observed
     $ gem install observed-clockwork
     $ gem install observed-http
 
-In this case, we use observed-clockwork to trigger polls through [Clockwork](https://github.com/tomykaira/clockwork).
-observed-clockwork is a library intended to use in Clockwork's configuration
-file. Clockwork is a scheduler process made with Ruby, which is intended to replace cron.
-Note that we can just use cron which is supported via observed-cron plugin(or even without the plugin, it is breeze to use
-Observed with cron) but we proceed with Clockwork just for example.
+For this example, we will use observed-clockwork to trigger polls through [Clockwork](https://github.com/tomykaira/clockwork).
+
+observed-clockwork is a library to be used with Clockwork's configuration file. Clockwork is a cron replacement for a scheduler process that is written in Ruby.
+
+Note that we can also use cron, which is supported via observed-cron plugin (even without the plugin it is really simple to use Observed with cron) but we will use Clockwork for this example.
 
-With `clockwork.rb` like:
+Edit the contents of `clockwork.rb`:
 
 ```ruby
 require 'pathname'
@@ -110,18 +87,17 @@ require 'observed/clockwork'
 
 include Clockwork
 
-# Below two lines are specific to Observed's Clockwork support.
-# Others lines are just standard `clockwork.rb`
-include Observed::Clockwork
-
 the_dir = Pathname.new(File.dirname(__FILE__))
 
+# The following two lines are specific to Observed's Clockwork support.
+include Observed::Clockwork
+
 register_observed_handler :config_file => the_dir + 'observed.rb'
 
 every(10.seconds, 'google.health')
 ```
 
-With `observed.rb` like:
+Edit the contents of `observed.rb` as follows:
 
 ```ruby
 require 'observed/http'
@@ -143,10 +119,10 @@ report /google.health/, via: 'stdout', with: {
 }
 ```
 
-As you see, `observed.conf` is just a Ruby source to describe Observed's configuration.
-You can rely on Ruby's language features, gems, or etc.
+As you see, `observed.rb` is just a Ruby source file that describes Observed's configuration.
+You can use Ruby language's features, gems, etc.
 
-We have finished configuring Observed.
+That sums up the configuration part of things.
 
 Now, run:
 
@@ -161,35 +137,34 @@ Google is healthy! (^o^)
 ...
 ```
 
-You did it!
-You just saw that Google's healthiness is printed to the standard output every 10 seconds.
-In other words, you did observed Google's healthiness with easily with Observed.
+And we're done! That's all it takes to print Google's health to standard output every 10 seconds with Observed.
 
-The example described here is fairly simple and would look useless at a glance, but remember that Observed is just a
-framework.
-If you want to monitor performances or get statistics on performance on your service, you can redirect the results to
-Fluentd, Ganglia or else and take advantages of their rich features and plugins.
-We like not reinventing the wheel and it is encouraged to use Observed for just to poll something and then emit the
-result to other services. Things like monitoring, watching, alerting can be done there.
+The example described here is fairly simple and may look useless at first glance, but keep in mind that Observed is just a framework.
+
+If you want to monitor performance or get statistics on performance on your service, you can redirect the results to Fluentd or other service to take advantage of their features and plugins.
+
+We prefer to not reinvent the wheel and encourage people to use Observed for polling and output results to other services for other tasks like monitoring or alerts.
 
 ## Documentation
 
 Observed is documented with [YARD](https://github.com/lsegal/yard).
-The documentation is not currently hosted on any server and we have to build the document before reading it.
 
-To generate the document, install YARD:
+The latest documentation for the master branch of Observed [is available at rubydoc.info](http://rubydoc.info/github/gree/observed).
+
+You can also generate the document locally.
+To do so, install YARD:
 
 ```
 $ gem install yard
 ```
 
-And then run `yardoc` like:
+And then run `yardoc` as follows:
 
 ```
 $ yardoc 'lib/**/*.rb'
 ```
 
-Open the document:
+You can then open the generated documentation:
 
 ```
 $ open doc/index.html
@@ -201,4 +176,4 @@ $ open doc/index.html
 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
+5.  Create a new pull request

data/examples/observed.rb

@@ -1,7 +1,7 @@
 class Test < Observed::Observer
   plugin_name 'test'
   def observe
-    system.report(tag, {foo:1})
+    [tag, {foo:1}]
   end
 end
 

data/exe/observed-oneshot

@@ -4,7 +4,9 @@ require 'observed'
 require 'observed/application/oneshot'
 
 begin
-  Observed::Application::Oneshot.from_argv(ARGV).run
+  argv = ARGV.dup
+  args = Observed::Application::Oneshot.parse_argv!(argv)
+  Observed::Application::Oneshot.create(args).run *argv
 rescue Observed::Application::Oneshot::InvalidArgumentError => e
   $stderr.puts 'Missing the path to a Observed config file'
   $stderr.puts 'Usage: observed-oneshot [-d|--debug] [-l LOG_FILE|--log_file LOG_FILE] <observed.rb>'

data/features/explicit_routing.feature

@@ -0,0 +1,33 @@
+Feature: Routing observed data without matching tags
+
+  In order to use Observed when the user's user-case is too simple that even tags are not needed
+  I want to write configs with reporters which have no regexp patterns to match observed data
+
+  Scenario: Create a .rb file containing Observed configuration and run it with the observed-oneshot command
+    Given a file named "test.rb" with:
+    """
+    require 'observed'
+
+    include Observed
+
+    class Test < Observed::Observer
+      plugin_name 'test'
+      def observe
+        system.report(tag, {foo:1})
+      end
+    end
+
+    observe_then_report = (observe 'foo', via: 'test')
+      .then(report via: 'stdout')
+
+    observe_then_report.now
+    """
+    When I run `ruby test.rb`
+    Then the output should contain:
+    """
+    {:foo=>1}
+    """
+    Then the output should not contain:
+    """
+    Error
+    """

data/features/oneshot.feature

@@ -22,3 +22,7 @@ Feature: Be testable in a single command
     """
     foo {:foo=>1}
     """
+    Then the output should not contain:
+    """
+    Error
+    """

data/features/test_in_single_ruby_source.feature

@@ -30,3 +30,7 @@ Feature: Be testable in a single Ruby source
     """
     foo {:foo=>1}
     """
+    Then the output should not contain:
+    """
+    Error
+    """

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

@@ -26,12 +26,11 @@ Feature: Running Observed inside Clockwork
         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
+          ::Thread.start {
+            sleep 1
+            exit
+          }
+          system.report(tag, {text: "Foo #{sleep_duration}"})
         end
 
         def logger
@@ -55,5 +54,5 @@ Feature: Running Observed inside Clockwork
     When I run `clockwork clockwork.rb`
     Then the output should contain:
     """
-    foo_1 Foo
+    00 foo_1 {:text=>"Foo
     """

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

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

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

@@ -10,7 +10,6 @@ module Observed
     def register_observed_handler(args)
       Observed.init!
       Observed.configure args
-      Observed.load! args[:config_file]
       ::Clockwork.handler do |job|
         Observed.run job
       end

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

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'clockwork'
   spec.add_dependency 'daemons'
-  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"
   spec.add_development_dependency "cucumber"

data/integrations/observed-eventmachine/.gitignore

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

data/integrations/observed-eventmachine/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in observed-eventmachine.gemspec
+gemspec
+
+group :development, :test do
+  gem 'observed'
+end

data/integrations/observed-eventmachine/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/integrations/observed-eventmachine/README.md

@@ -0,0 +1,29 @@
+# Observed::Eventmachine
+
+A simple, experimental integration of Observed and EventMachine.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'observed-eventmachine'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install observed-eventmachine
+
+## Usage
+
+See examples under "examples/" and the cucumber tests under "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/integrations/observed-eventmachine/Rakefile

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

data/integrations/observed-eventmachine/examples/observed.rb

@@ -0,0 +1,30 @@
+require 'observed'
+require 'observed/eventmachine'
+
+include Observed
+
+# This is a observed-eventmachine specific code to extend the DSL to use EventMachine
+extend Observed::EM
+
+class Test < Observed::Observer
+  plugin_name 'test'
+  def observe
+    puts "Sleeping 10 seconds"
+    sleep 10.0
+    puts "Slept 10 seconds"
+    [tag, {foo:1}]
+  end
+end
+
+observe 'foo', via: 'test'
+
+report /foo/, via: 'stdout', with: {
+  format: -> _, _, data { "#{data}" }
+}
+
+# This is a observed-eventmachine specific code to schedule the observation on 'foo'
+every 1, run: 'foo'
+
+# This is a observed-eventmachine specific code to start running observations periodically, until we stop that by
+# sending signals
+start

data/integrations/observed-eventmachine/features/integration_via_single_ruby_source.feature

@@ -0,0 +1,48 @@
+Feature: Integration via single Ruby source
+
+  In order to easily integrate Observed with EventMachine,
+  I want to extend Observed's DSL with words specific to the EventMachine integration,
+  and make it runnable and testable in single Ruby source.
+
+  Scenario: Create a .rb file containing Observed code and run it with the ruby command
+    Given a file named "test.rb" with:
+    """
+    require 'observed'
+    require 'observed/eventmachine'
+
+    include Observed
+
+    extend Observed::EM
+
+    $count = 0
+
+    class Test < Observed::Observer
+      plugin_name 'test'
+      def observe
+        $count += 1
+        system.report(tag, {foo:1})
+        if $count >= 2
+          Thread.start {
+            sleep 1
+            exit
+          }
+        end
+      end
+    end
+
+    observe 'foo', via: 'test'
+
+    report /foo/, via: 'stdout', with: {
+      format: -> tag, _, data { "#{tag} #{$count} #{data}" }
+    }
+
+    every 1, run: 'foo'
+
+    start
+    """
+    When I run `ruby test.rb`
+    Then the output should contain:
+    """
+    foo 1 {:foo=>1}
+    foo 2 {:foo=>1}
+    """

data/integrations/observed-eventmachine/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 = 120
+end

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

@@ -0,0 +1,5 @@
+module Observed
+  module EM
+    VERSION = "0.0.1"
+  end
+end

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

@@ -0,0 +1,70 @@
+require "eventmachine"
+require "observed/eventmachine/version"
+
+module Observed
+  module EM
+
+    # Schedule the observation to run it periodically
+    # @param [Float|Fixnum] seconds
+    # @param [Hash] args
+    # @option args [String] :run The tag of the observation to schedule running. It is the one registered via the code
+    #                            `observe tag, via: 'observer_plugin_name'`.
+    def every(seconds, args)
+      @builder.every seconds, args
+    end
+
+    # Start EventMachine and run scheduled observations.
+    def start
+      ::EM.run do
+        Signal.trap("INT")  { ::EventMachine.stop }
+        Signal.trap("TERM") { ::EventMachine.stop }
+        @builder.periodic_tasks.each do |periodic_task|
+          ::EM.add_periodic_timer(periodic_task.seconds) do
+            ::EM.defer { run(periodic_task.tag) }
+          end
+        end
+      end
+    end
+
+    # Automatically called on `extend Observed::EM`
+    def init_observed_em_builder
+      @builder = Builder.new
+    end
+
+    def self.extended(klass)
+      klass.init_observed_em_builder
+    end
+
+    class Builder
+
+      # Schedule the observation to run it periodically.
+      # Scheduled observations can be obtained later by calling the method `periodic_tasks`.
+      # @param [Float|Fixnum] seconds The interval to run the observation, in seconds.
+      # @param [Hash] args
+      # @option args [String] :run The tag of the observation to schedule running. It is the one registered via the code
+      #                            `observe tag, via: 'observer_plugin_name'`.
+      def every(seconds, args)
+        periodic_tasks << PeriodicTask.new(seconds, args)
+      end
+
+      def periodic_tasks
+        @periodic_tasks ||= []
+      end
+    end
+
+    class PeriodicTask
+      attr_reader :seconds
+      attr_reader :args
+
+      def initialize(seconds, args)
+        @seconds = seconds
+        @args = args
+      end
+
+      def tag
+        args[:run]
+      end
+    end
+
+  end
+end