fluent-plugin-notifier 0.1.0 → 0.2.0

data/README.md

@@ -8,8 +8,6 @@ Plugin to emit notifications for messages, with numbers over/under threshold, or
 
 ## Configuration
 
-### NotifierOutput
-
 To notify apache logs with over 1000000 (microseconds) duration for CRITICAL , or status '500' by string pattern match:
 
     <match apache.log.**>
@@ -52,6 +50,77 @@ Default configurations:
 
 If you want to get every 5 minutes notifications (after 1 minutes notifications), specify '0' for 'repetitions\_2nd'.
 
+### Message Testing
+
+To include specified messages into check target, or to exclude specified messages from check target, <test> directive is useful.
+
+    <match apache.log.**>
+      type notifier
+      <test>
+        check numeric
+        target_key duration     # microseconds
+        lower_threshold 5000    # 5ms
+        upper_threshold 5000000 # 5s
+      </test>
+      <def>
+        pattern status_500
+        check string_find
+        warn_regexp 5\d\d
+        crit_regexp 500
+        target_key_pattern ^status.*$
+      </def>
+    </match>
+
+With configuration above, fluent-plugin-notifier checks messages with specified duration value (d: 5000 <= d <= 5000000), and others are ignored.
+
+Available 'check' types are: 'numeric', 'regexp' and 'tag'.
+
+* numeric
+  * 'lower\_threshold', 'upper\_threshold' and both are available
+* regexp, tag
+  * 'include\_pattern', 'exclude\_pattern' and both are available
+  * 'tag' checks tag strings after 'input\_tag\_remove\_prefix'
+
+Multiple <test> directives means logical AND of each tests.
+
+    <match apache.log.**>
+      type notifier
+      input_tag_remove_prefix apache.log
+      <test>
+        check tag
+        include_pattern ^news[123]$ # for specified web server log
+      </test>
+      <test>
+        check numeric
+        target_key duration     # microseconds
+        lower_threshold 5000    # 5ms
+      </test>
+      <test>
+        check regexp
+        target_key vhost
+        exclude_pattern ^image.news.example.com$  # ingore image delivery server log
+      </test>
+      <test>
+        check regexp
+        target_key path
+        include_pattern ^/path/to/contents/    # for specified content path only
+        exclude_pattern \.(gif|jpg|png|swf)$   # but image files are ignored
+      </test>
+      <def>
+        pattern status_500
+        check string_find
+        warn_regexp 5\d\d
+        crit_regexp 500
+        target_key_pattern ^status.*$
+      </def>
+    </match>
+
+Notifier plugin configured like this will check messages:
+ * with tag 'apache.log.news1', 'apache.log.news2' or 'apache.log.news3'
+ * with duration bigger than 5ms (upper unlimited)
+ * without vhost image.news.example.com
+ * with request path '/path/to/contents/*' and without file suffix gif/jpg/png/swf.
+
 ## TODO
 
 * patches welcome!

data/fluent-plugin-notifier.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |gem|
   gem.name          = "fluent-plugin-notifier"
-  gem.version       = "0.1.0"
+  gem.version       = "0.2.0"
   gem.authors       = ["TAGOMORI Satoshi"]
   gem.email         = ["tagomoris@gmail.com"]
   gem.summary       = %q{check matched messages and emit alert message}

data/lib/fluent/plugin/out_notifier.rb

@@ -16,7 +16,9 @@ class Fluent::NotifierOutput < Fluent::Output
   config_param :default_repetitions_2nd, :integer, :default => 5
   config_param :default_interval_3rd, :time, :default => 1800
 
-  attr_accessor :defs, :states, :match_cache, :negative_cache
+  config_param :input_tag_remove_prefix, :string, :default => nil
+
+  attr_accessor :tests, :defs, :states, :match_cache, :negative_cache
   
 ### output
 # {
@@ -38,6 +40,18 @@ class Fluent::NotifierOutput < Fluent::Output
 #   default_interval_2nd 5m
 #   default_repetitions_2nd 5
 #   default_interval_3rd 30m
+#   <test>
+#     check numeric
+#     target_key xxx
+#     lower_threshold xxx
+#     upper_threshold xxx
+#   </test>
+#   <test>
+#     check regexp
+#     target_key xxx
+#     include_pattern ^.$
+#     exclude_pattern ^.$
+#   </test>
 #   <def>
 #     pattern http_status_errors
 #     check numeric_upward
@@ -65,9 +79,15 @@ class Fluent::NotifierOutput < Fluent::Output
 
     @match_cache = {} # cache which has map (fieldname => definition(s))
     @negative_cache = {}
+    @tests = []
     @defs = []
     @states = {} # key: tag+field ?
 
+    if @input_tag_remove_prefix
+      @input_tag_remove_prefix_string = @input_tag_remove_prefix + '.'
+      @input_tag_remove_prefix_length = @input_tag_remove_prefix_string.length
+    end
+
     defaults = {
       :tag => @default_tag, :tag_warn => @default_tag_warn, :tag_crit => @default_tag_crit,
       :interval_1st => @default_interval_1st, :repetitions_1st => @default_repetitions_1st,
@@ -76,10 +96,14 @@ class Fluent::NotifierOutput < Fluent::Output
     }
 
     conf.elements.each do |element|
-      if element.name != 'def'
-        raise Fluent::ConfigError, "invalid section name for out_notifier: #{d.name}"
+      case element.name
+      when 'test'
+        @tests.push(Test.new(element))
+      when 'def'
+        @defs.push(Definition.new(element, defaults))
+      else
+        raise Fluent::ConfigError, "invalid section name for out_notifier: #{element.name}"
       end
-      defs.push(Definition.new(element, defaults))
     end
   end
 
@@ -120,12 +144,18 @@ class Fluent::NotifierOutput < Fluent::Output
     end
   end
 
-  def emit(tag, es, chain)
+  def check(tag, es)
     notifications = []
 
+    tag = if @input_tag_remove_prefix and
+              tag.start_with?(@input_tag_remove_prefix_string) and tag.length > @input_tag_remove_prefix_length
+            tag[@input_tag_remove_prefix_length..-1]
+          else
+            tag
+          end
+
     es.each do |time,record|
       record.keys.each do |key|
-
         next if @negative_cache[key]
 
         defs = @match_cache[key]
@@ -134,12 +164,12 @@ class Fluent::NotifierOutput < Fluent::Output
           @defs.each do |d|
             defs.push(d) if d.match?(key)
           end
-          if defs.size < 1
-            @negative_cache[key] = true
-          end
+          @negative_cache[key] = true if defs.size < 1
         end
 
         defs.each do |d|
+          next unless @tests.reduce(true){|r,t| r and t.test(tag, record)}
+
           alert = d.check(tag, time, record, key)
           if alert
             notifications.push(alert)
@@ -148,6 +178,12 @@ class Fluent::NotifierOutput < Fluent::Output
       end
     end
 
+    notifications
+  end
+
+  def emit(tag, es, chain)
+    notifications = check(tag, es)
+
     if notifications.size > 0
       @mutex.synchronize do
         suppressed_emit(notifications)
@@ -164,6 +200,73 @@ class Fluent::NotifierOutput < Fluent::Output
     chain.next
   end
 
+  class Test
+    attr_accessor :check, :target_key
+    attr_accessor :lower_threshold, :upper_threshold
+    attr_accessor :include_pattern, :exclude_pattern
+
+    def initialize(element)
+      element.keys.each do |k|
+        v = element[k]
+        case k
+        when 'check'
+          case v
+          when 'tag'
+            @check = :tag
+            @include_pattern = element['include_pattern'] ? Regexp.compile(element['include_pattern']) : nil
+            @exclude_pattern = element['exclude_pattern'] ? Regexp.compile(element['exclude_pattern']) : nil
+            if @include_pattern.nil? and @exclude_pattern.nil?
+              raise Fluent::ConfigError, "At least one of include_pattern or exclude_pattern must be specified for 'check tag'"
+            end
+          when 'numeric'
+            @check = :numeric
+            @lower_threshold = element['lower_threshold'] ? element['lower_threshold'].to_f : nil
+            @upper_threshold = element['upper_threshold'] ? element['upper_threshold'].to_f : nil
+            if @lower_threshold.nil? and @upper_threshold.nil?
+              raise Fluent::ConfigError, "At least one of lower_threshold or upper_threshold must be specified for 'check numeric'"
+            end
+          when 'regexp'
+            @check = :regexp
+            @include_pattern = element['include_pattern'] ? Regexp.compile(element['include_pattern']) : nil
+            @exclude_pattern = element['exclude_pattern'] ? Regexp.compile(element['exclude_pattern']) : nil
+            if @include_pattern.nil? and @exclude_pattern.nil?
+              raise Fluent::ConfigError, "At least one of include_pattern or exclude_pattern must be specified for 'check regexp'"
+            end
+          else
+            raise Fluent::ConfigError, "invalid check value of test [numeric/regexp]: '#{v}'"
+          end
+        when 'target_key'
+          @target_key = v
+        end
+      end
+      unless @check
+        raise Fluent::ConfigError, "'check' missing in <test> section"
+      end
+      if @target_key.nil? and @check != :tag
+        raise Fluent::ConfigError, "'target_key' missing in <test> section"
+      end
+    end
+
+    def test(tag, record)
+      v = case @check
+          when :numeric, :regexp
+            record[@target_key]
+          when :tag
+            tag
+          end
+      return false if v.nil?
+
+      case @check
+      when :numeric
+        v = v.to_f
+        (@lower_threshold.nil? or @lower_threshold <= v) and (@upper_threshold.nil? or v <= @upper_threshold)
+      when :tag, :regexp
+        v = v.to_s.force_encoding('ASCII-8BIT')
+        ((@include_pattern.nil? or @include_pattern.match(v)) and (@exclude_pattern.nil? or (not @exclude_pattern.match(v)))) or false
+      end
+    end
+  end
+
   class Definition
     attr_accessor :tag, :tag_warn, :tag_crit
     attr_accessor :intervals, :repetitions
@@ -180,14 +283,23 @@ class Fluent::NotifierOutput < Fluent::Output
           case element[k]
           when 'numeric_upward'
             @check = :upward
+            unless element.has_key?('crit_threshold') and element.has_key?('warn_threshold')
+              raise Fluent::ConfigError, "Both of crit_threshold and warn_threshold must be specified for 'check numeric_upward'"
+            end
             @crit_threshold = element['crit_threshold'].to_f
             @warn_threshold = element['warn_threshold'].to_f
           when 'numeric_downward'
             @check = :downward
+            unless element.has_key?('crit_threshold') and element.has_key?('warn_threshold')
+              raise Fluent::ConfigError, "Both of crit_threshold and warn_threshold must be specified for 'check_numeric_downward'"
+            end
             @crit_threshold = element['crit_threshold'].to_f
             @warn_threshold = element['warn_threshold'].to_f
           when 'string_find'
             @check = :find
+            unless element.has_key?('crit_regexp') and element.has_key?('warn_regexp')
+              raise Fluent::ConfigError, "Both of crit_regexp and warn_regexp must be specified for 'check string_find'"
+            end
             @crit_regexp = Regexp.compile(element['crit_regexp'].to_s)
             @warn_regexp = Regexp.compile(element['warn_regexp'].to_s)
           else

data/test/plugin/test_out_notifier.rb

@@ -2,8 +2,110 @@ require 'helper'
 
 class NotifierOutputTest < Test::Unit::TestCase
   CONFIG = %[
+  type notifier
+  input_tag_remove_prefix test
+  <test>
+    check numeric
+    target_key numfield
+    lower_threshold 2.5
+    upper_threshold 5000
+  </test>
+  <test>
+    check regexp
+    target_key textfield
+    include_pattern Target.*
+    exclude_pattern TargetC
+  </test>
+  <def>
+    pattern pattern1
+    check numeric_upward
+    warn_threshold 25
+    crit_threshold 50
+    tag_warn alert.warn
+    tag_crit alert.crit
+    target_keys num1,num2,num3
+  </def>
+  <def>
+    pattern pattern2
+    check string_find
+    crit_regexp ERROR
+    warn_regexp WARNING
+    tag alert
+    target_key_pattern ^message.*$
+  </def>
 ]
+
   def create_driver(conf=CONFIG,tag='test')
     Fluent::Test::OutputTestDriver.new(Fluent::NotifierOutput, tag).configure(conf)
   end
+
+  def test_configure
+    d = create_driver
+    assert_nil nil # no one exception raised
+  end
+
+  def test_emit
+    d = create_driver
+    d.run do
+      d.emit({'num1' => 20, 'message' => 'INFO'})
+    end
+    assert_equal 0, d.emits.size
+
+    d = create_driver
+    d.run do
+      d.emit({'num1' => 30, 'message' => 'INFO'})
+    end
+    assert_equal 0, d.emits.size
+
+    d = create_driver(CONFIG, 'test.input')
+    d.run do
+      d.emit({'num1' => 30, 'message' => 'INFO', 'numfield' => '30', 'textfield' => 'TargetX'})
+    end
+    assert_equal 1, d.emits.size
+    assert_equal 'alert.warn', d.emits[0][0]
+    assert_equal 'pattern1', d.emits[0][2]['pattern']
+    assert_equal 'input', d.emits[0][2]['target_tag']
+    assert_equal 'numeric_upward', d.emits[0][2]['check_type']
+    assert_equal 'warn', d.emits[0][2]['level']
+    assert_equal 25.0, d.emits[0][2]['threshold']
+    assert_equal 30.0, d.emits[0][2]['value']
+
+    d = create_driver
+    d.run do
+      d.emit({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '30', 'textfield' => 'TargetX'})
+    end
+    assert_equal 2, d.emits.size
+    assert_equal 'alert.crit', d.emits[0][0]
+    assert_equal 'pattern1', d.emits[0][2]['pattern']
+    assert_equal 'test', d.emits[0][2]['target_tag']
+    assert_equal 'numeric_upward', d.emits[0][2]['check_type']
+    assert_equal 'crit', d.emits[0][2]['level']
+    assert_equal 50.0, d.emits[0][2]['threshold']
+    assert_equal 60.0, d.emits[0][2]['value']
+    assert_equal 'alert', d.emits[1][0]
+    assert_equal 'pattern2', d.emits[1][2]['pattern']
+    assert_equal 'test', d.emits[1][2]['target_tag']
+    assert_equal 'string_find', d.emits[1][2]['check_type']
+    assert_equal 'warn', d.emits[1][2]['level']
+    assert_equal '/WARNING/', d.emits[1][2]['regexp']
+    assert_equal 'foo bar WARNING xxxxx', d.emits[1][2]['value']
+
+    d = create_driver
+    d.run do
+      d.emit({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '2.4', 'textfield' => 'TargetX'})
+    end
+    assert_equal 0, d.emits.size
+
+    d = create_driver
+    d.run do
+      d.emit({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '20', 'textfield' => 'TargetC'})
+    end
+    assert_equal 0, d.emits.size
+
+    d = create_driver
+    d.run do
+      d.emit({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '20'})
+    end
+    assert_equal 0, d.emits.size
+  end
 end

data/test/plugin/test_test.rb

@@ -0,0 +1,178 @@
+require 'helper'
+
+class NotifierOutputTestTest < Test::Unit::TestCase
+  TEST_CONF1 = {
+    'check' => 'numeric', 'target_key' => 'field1',
+    'lower_threshold' => '1', 'upper_threshold' => '2',
+  }
+  TEST_CONF2 = {
+    'check' => 'numeric', 'target_key' => 'field1',
+    'lower_threshold' => '1',
+  }
+  TEST_CONF3 = {
+    'check' => 'numeric', 'target_key' => 'field1',
+    'upper_threshold' => '2',
+  }
+  TEST_CONF4 = {
+    'check' => 'regexp', 'target_key' => 'field2',
+    'include_pattern' => 'hoge', 'exclude_pattern' => 'pos',
+  }
+  TEST_CONF5 = {
+    'check' => 'regexp', 'target_key' => 'field2',
+    'include_pattern' => 'hoge',
+  }
+  TEST_CONF6 = {
+    'check' => 'regexp', 'target_key' => 'field2',
+    'exclude_pattern' => 'pos',
+  }
+  TEST_CONF7 = {
+    'check' => 'tag',
+    'include_pattern' => 'hoge',
+    'exclude_pattern' => 'pos',
+  }
+  TEST_CONF8 = {
+    'check' => 'tag',
+    'include_pattern' => 'hoge',
+  }
+  TEST_CONF9 = {
+    'check' => 'tag',
+    'exclude_pattern' => 'pos',
+  }
+
+  def test_init
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF1)
+    assert_equal :numeric, t.check
+    assert_equal 'field1', t.target_key
+    assert_equal 1.0, t.lower_threshold
+    assert_equal 2.0, t.upper_threshold
+
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF4)
+    assert_equal :regexp, t.check
+    assert_equal 'field2', t.target_key
+    assert_equal /hoge/, t.include_pattern
+    assert_equal /pos/, t.exclude_pattern
+
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF7)
+    assert_equal :tag, t.check
+    assert_nil t.target_key
+    assert_equal /hoge/, t.include_pattern
+    assert_equal /pos/, t.exclude_pattern
+  end
+
+  def test_numeric
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF1)
+    assert_equal :numeric, t.check
+    assert_equal 'field1', t.target_key
+    assert_equal 1.0, t.lower_threshold
+    assert_equal 2.0, t.upper_threshold
+
+    assert_equal false, t.test('test', {'field2' => '0.5'})
+    assert_equal false, t.test('test', {'field1' => '0.5'})
+    assert_equal true, t.test('test', {'field1' => 1})
+    assert_equal true, t.test('test', {'field1' => 1.999999999999999999999999999999})
+    assert_equal true, t.test('test', {'field1' => 2.0})
+    assert_equal false, t.test('test', {'field1' => '2.0000001'})
+
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF2)
+    # TEST_CONF2 = {
+    #   'check' => 'numeric', 'target_key' => 'field1',
+    #   'lower_threshold' => '1',
+    # }
+    assert_equal false, t.test('test', {'field2' => '0.5'})
+    assert_equal false, t.test('test', {'field1' => '0.5'})
+    assert_equal true, t.test('test', {'field1' => 1})
+    assert_equal true, t.test('test', {'field1' => 1.999999999999999999999999999999})
+    assert_equal true, t.test('test', {'field1' => 2.0})
+    assert_equal true, t.test('test', {'field1' => '2.0000001'})
+    assert_equal true, t.test('test', {'field1' => 10000.32})
+
+
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF3)
+    # TEST_CONF3 = {
+    #   'check' => 'numeric', 'target_key' => 'field1',
+    #   'upper_threshold' => '2',
+    # }
+    assert_equal false, t.test('test', {'field2' => '0.5'})
+    assert_equal true, t.test('test', {'field1' => '0.5'})
+    assert_equal true, t.test('test', {'field1' => 1})
+    assert_equal true, t.test('test', {'field1' => 1.999999999999999999999999999999})
+    assert_equal true, t.test('test', {'field1' => 2.0})
+    assert_equal false, t.test('test', {'field1' => '2.0000001'})
+    assert_equal false, t.test('test', {'field1' => 10000.32})
+
+    assert_equal true, t.test('test', {'field1' => 0.0})
+    assert_equal true, t.test('test', {'field1' => '-1'})
+  end
+
+  def test_regexp
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF4)
+    assert_equal :regexp, t.check
+    assert_equal 'field2', t.target_key
+    assert_equal /hoge/, t.include_pattern
+    assert_equal /pos/, t.exclude_pattern
+
+    assert_equal false, t.test('test', {'field1' => 'hoge foo bar'})
+    assert_equal false, t.test('test', {'field2' => ''})
+    assert_equal true, t.test('test', {'field2' => 'hoge foo bar'})
+    assert_equal false, t.test('test', {'field2' => 'hoge pos foo bar'})
+    assert_equal false, t.test('test', {'field2' => 'pos foo bar'})
+    assert_equal false, t.test('test', {'field2' => 'pos hoge foo bar'})
+    assert_equal true, t.test('test', {'field2' => 'hoge foo bar hoge'})
+
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF5)
+    # TEST_CONF5 = {
+    #   'check' => 'regexp', 'target_key' => 'field2',
+    #   'include_pattern' => 'hoge',
+    # }
+    assert_equal false, t.test('test', {'field1' => 'hoge foo bar'})
+    assert_equal false, t.test('test', {'field2' => ''})
+    assert_equal true, t.test('test', {'field2' => 'hoge foo bar'})
+    assert_equal true, t.test('test', {'field2' => 'hoge pos foo bar'})
+    assert_equal false, t.test('test', {'field2' => 'pos foo bar'})
+    assert_equal true, t.test('test', {'field2' => 'pos hoge foo bar'})
+    assert_equal true, t.test('test', {'field2' => 'hoge foo bar hoge'})
+
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF6)
+    # TEST_CONF6 = {
+    #   'check' => 'regexp', 'target_key' => 'field2',
+    #   'exclude_pattern' => 'pos',
+    # }
+    assert_equal false, t.test('test', {'field1' => 'hoge foo bar'})
+    assert_equal true, t.test('test', {'field2' => ''})
+    assert_equal true, t.test('test', {'field2' => 'hoge foo bar'})
+    assert_equal false, t.test('test', {'field2' => 'hoge pos foo bar'})
+    assert_equal false, t.test('test', {'field2' => 'pos foo bar'})
+    assert_equal false, t.test('test', {'field2' => 'pos hoge foo bar'})
+    assert_equal true, t.test('test', {'field2' => 'hoge foo bar hoge'})
+  end
+
+  def test_tag
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF7)
+    # TEST_CONF7 = {
+    #   'check' => 'tag',
+    #   'include_pattern' => 'hoge',
+    #   'exclude_pattern' => 'pos',
+    # }
+    assert_equal false, t.test('test', {'field1' => 'hoge foo bar'})
+    assert_equal true, t.test('test.hoge', {'field1' => 'hoge foo bar'})
+    assert_equal false, t.test('test.hoge.pos', {'field1' => 'hoge foo bar'})
+
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF8)
+    # TEST_CONF8 = {
+    #   'check' => 'tag',
+    #   'include_pattern' => 'hoge',
+    # }
+    assert_equal false, t.test('test', {'field1' => 'hoge foo bar'})
+    assert_equal true, t.test('test.hoge', {'field1' => 'hoge foo bar'})
+    assert_equal true, t.test('test.hoge.pos', {'field1' => 'hoge foo bar'})
+
+    t = Fluent::NotifierOutput::Test.new(TEST_CONF9)
+    # TEST_CONF9 = {
+    #   'check' => 'tag',
+    #   'exclude_pattern' => 'pos',
+    # }
+    assert_equal true, t.test('test', {'field1' => 'hoge foo bar'})
+    assert_equal true, t.test('test.hoge', {'field1' => 'hoge foo bar'})
+    assert_equal false, t.test('test.hoge.pos', {'field1' => 'hoge foo bar'})
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-notifier
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-19 00:00:00.000000000 Z
+date: 2012-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -77,6 +77,7 @@ files:
 - test/plugin/test_def.rb
 - test/plugin/test_out_notifier.rb
 - test/plugin/test_state.rb
+- test/plugin/test_test.rb
 homepage: https://github.com/tagomoris/fluent-plugin-notifier
 licenses: []
 post_install_message: 
@@ -106,3 +107,4 @@ test_files:
 - test/plugin/test_def.rb
 - test/plugin/test_out_notifier.rb
 - test/plugin/test_state.rb
+- test/plugin/test_test.rb