fluent-plugin-notifier 0.0.2 → 0.1.0

data/README.md

@@ -27,6 +27,7 @@ To notify apache logs with over 1000000 (microseconds) duration for CRITICAL , o
         warn_regexp 5\d\d
         crit_regexp 500
         target_key_pattern ^status.*$
+        exclude_key_pattern ^status_ignore_.*$  # key name not to notify about...
       </def>
     </match>
 
@@ -53,7 +54,7 @@ If you want to get every 5 minutes notifications (after 1 minutes notifications)
 
 ## TODO
 
-* long run
+* patches welcome!
 
 ## Copyright
 

data/Rakefile

@@ -1,2 +1,11 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

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.0.2"
+  gem.version       = "0.1.0"
   gem.authors       = ["TAGOMORI Satoshi"]
   gem.email         = ["tagomoris@gmail.com"]
   gem.summary       = %q{check matched messages and emit alert message}
@@ -13,6 +13,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.add_development_dependency "rake"
   gem.add_development_dependency "fluentd"
   gem.add_runtime_dependency "fluentd"
 end

data/lib/fluent/plugin/out_notifier.rb

@@ -167,7 +167,7 @@ class Fluent::NotifierOutput < Fluent::Output
   class Definition
     attr_accessor :tag, :tag_warn, :tag_crit
     attr_accessor :intervals, :repetitions
-    attr_accessor :pattern, :check, :target_keys, :target_key_pattern, :exclude_keys, :exclude_key_pattern
+    attr_accessor :pattern, :check, :target_keys, :target_key_pattern, :exclude_key_pattern
     attr_accessor :crit_threshold, :warn_threshold # for 'numeric_upward', 'numeric_downward'
     attr_accessor :crit_regexp, :warn_regexp # for 'string_find'
 
@@ -195,7 +195,6 @@ class Fluent::NotifierOutput < Fluent::Output
           end
         when 'target_keys'
           @target_keys = element['target_keys'].split(',')
-          @exclude_keys = (element['exclude_keys'] || '').split(',')
         when 'target_key_pattern'
           @target_key_pattern = Regexp.compile(element['target_key_pattern'])
           @exclude_key_pattern = Regexp.compile(element['exclude_key_pattern'] || '^$')
@@ -223,7 +222,7 @@ class Fluent::NotifierOutput < Fluent::Output
 
     def match?(key)
       if @target_keys
-        @target_keys.include?(key) and not @exclude_keys.include?(key)
+        @target_keys.include?(key)
       elsif @target_key_pattern
         @target_key_pattern.match(key) and not @exclude_key_pattern.match(key)
       end
@@ -242,61 +241,64 @@ class Fluent::NotifierOutput < Fluent::Output
     def check(tag, time, record, key)
       case @check
       when :upward
-        if @crit_threshold and record[key].to_f >= @crit_threshold
+        value = record[key].to_f
+        if @crit_threshold and value >= @crit_threshold
           {
             :hashkey => @pattern + "\t" + tag + "\t" + key,
             :match_def => self,
             :emit_tag => (@tag_crit || @tag),
             'pattern' => @pattern, 'target_tag' => tag, 'target_key' => key, 'check_type' => 'numeric_upward', 'level' => 'crit',
-            'threshold' => @crit_threshold, 'value' => record[key], 'message_time' => Time.at(time).to_s
+            'threshold' => @crit_threshold, 'value' => value, 'message_time' => Time.at(time).to_s
           }
-        elsif @warn_threshold and record[key].to_f >= @warn_threshold
+        elsif @warn_threshold and value >= @warn_threshold
           {
             :hashkey => @pattern + "\t" + tag + "\t" + key,
             :match_def => self,
             :emit_tag => (@tag_warn || @tag),
             'pattern' => @pattern, 'target_tag' => tag, 'target_key' => key, 'check_type' => 'numeric_upward', 'level' => 'warn',
-            'threshold' => @warn_threshold, 'value' => record[key], 'message_time' => Time.at(time).to_s
+            'threshold' => @warn_threshold, 'value' => value, 'message_time' => Time.at(time).to_s
           }
         else
           nil
         end
       when :downward
-        if @crit_threshold and record[key].to_f <= @crit_threshold
+        value = record[key].to_f
+        if @crit_threshold and value <= @crit_threshold
           {
             :hashkey => @pattern + "\t" + tag + "\t" + key,
             :match_def => self,
             :emit_tag => (@tag_crit || @tag),
             'pattern' => @pattern, 'target_tag' => tag, 'target_key' => key, 'check_type' => 'numeric_downward', 'level' => 'crit',
-            'threshold' => @crit_threshold, 'value' => record[key], 'message_time' => Time.at(time).to_s
+            'threshold' => @crit_threshold, 'value' => value, 'message_time' => Time.at(time).to_s
           }
-        elsif @warn_threshold and record[key].to_f <= @warn_threshold
+        elsif @warn_threshold and value <= @warn_threshold
           {
             :hashkey => @pattern + "\t" + tag + "\t" + key,
             :match_def => self,
             :emit_tag => (@tag_warn || @tag),
             'pattern' => @pattern, 'target_tag' => tag, 'target_key' => key, 'check_type' => 'numeric_downward', 'level' => 'warn',
-            'threshold' => @warn_threshold, 'value' => record[key], 'message_time' => Time.at(time).to_s
+            'threshold' => @warn_threshold, 'value' => value, 'message_time' => Time.at(time).to_s
           }
         else
           nil
         end
       when :find
-        if @crit_regexp and @crit_regexp.match(record[key].to_s)
+        str = record[key].to_s
+        if @crit_regexp and @crit_regexp.match(str)
           {
             :hashkey => @pattern + "\t" + tag + "\t" + key,
             :match_def => self,
             :emit_tag => (@tag_crit || @tag),
             'pattern' => @pattern, 'target_tag' => tag, 'target_key' => key, 'check_type' => 'string_find', 'level' => 'crit',
-            'regexp' => @crit_regexp.inspect, 'value' => record[key], 'message_time' => Time.at(time).to_s
+            'regexp' => @crit_regexp.inspect, 'value' => str, 'message_time' => Time.at(time).to_s
           }
-        elsif @warn_regexp and @warn_regexp.match(record[key].to_s)
+        elsif @warn_regexp and @warn_regexp.match(str)
           {
             :hashkey => @pattern + "\t" + tag + "\t" + key,
             :match_def => self,
             :emit_tag => (@tag_warn || @tag),
             'pattern' => @pattern, 'target_tag' => tag, 'target_key' => key, 'check_type' => 'string_find', 'level' => 'warn',
-            'regexp' => @warn_regexp.inspect, 'value' => record[key], 'message_time' => Time.at(time).to_s
+            'regexp' => @warn_regexp.inspect, 'value' => str, 'message_time' => Time.at(time).to_s
           }
         else
           nil

data/test/plugin/test_def.rb

@@ -0,0 +1,143 @@
+require 'helper'
+
+class NotifierOutputDefinitionTest < Test::Unit::TestCase
+  TEST_DEFAULTS = {
+    :tag => 'n', :tag_warn => nil, :tag_crit => nil,
+    :interval_1st => 60, :repetitions_1st => 5,
+    :interval_2nd => 300, :repetitions_2nd => 5,
+    :interval_3rd => 1800
+  }
+
+  TEST_CONF1 = {
+    'tag' => 'notify',
+    'pattern' => 'name1', 'target_keys' => 'field1,field2',
+    'check' => 'numeric_upward', 'warn_threshold' => '1', 'crit_threshold' => '2',
+  }
+
+  TEST_CONF2 = {
+    'tag_warn' => 'warn', 'tag_crit' => 'crit',
+    'pattern' => 'name2', 'target_key_pattern' => '^field\d$',
+    'check' => 'string_find', 'warn_regexp' => 'WARN', 'crit_regexp' => 'CRIT',
+    'interval_1st' => 5, 'repetitions_1st' => 1,
+    'interval_2nd' => 6, 'repetitions_2nd' => 2,
+    'interval_3rd' => 7
+  }
+
+  def test_init
+    d = Fluent::NotifierOutput::Definition.new(TEST_CONF1, TEST_DEFAULTS)
+    assert_equal 'name1', d.pattern
+    assert_equal ['field1','field2'], d.target_keys
+    assert_equal :upward, d.instance_eval{ @check }
+    assert_equal 2.0, d.crit_threshold
+    assert_equal 1.0, d.warn_threshold
+    assert_equal 'notify', d.tag
+    assert_nil d.tag_warn
+    assert_nil d.tag_crit
+    assert_equal [60, 300, 1800], d.intervals
+    assert_equal [5, 5], d.repetitions
+
+    d = Fluent::NotifierOutput::Definition.new(TEST_CONF2, TEST_DEFAULTS)
+    assert_equal 'name2', d.pattern
+    assert_equal /^field\d$/, d.target_key_pattern
+    assert_equal /^$/, d.exclude_key_pattern
+    assert_equal :find, d.instance_eval{ @check }
+    assert_equal /WARN/, d.warn_regexp
+    assert_equal /CRIT/, d.crit_regexp
+    assert_equal 'n', d.tag
+    assert_equal 'warn', d.tag_warn
+    assert_equal 'crit', d.tag_crit
+    assert_equal [5, 6, 7], d.intervals
+    assert_equal [1, 2], d.repetitions
+  end
+
+  def test_match
+    d = Fluent::NotifierOutput::Definition.new(TEST_CONF1, TEST_DEFAULTS)
+    assert_equal true, d.match?('field1')
+    assert_equal true, d.match?('field2')
+    assert ! d.match?('field0')
+    assert ! d.match?('field')
+    assert ! d.match?('')
+
+    d = Fluent::NotifierOutput::Definition.new(TEST_CONF2, TEST_DEFAULTS)
+    assert_equal true, d.match?('field0')
+    assert_equal true, d.match?('field1')
+    assert_equal true, d.match?('field9')
+    assert ! d.match?('field')
+    assert ! d.match?('fieldx')
+    assert ! d.match?(' field0')
+    assert ! d.match?('field0 ')
+
+    d = Fluent::NotifierOutput::Definition.new(TEST_CONF2.merge({'exclude_key_pattern' => '^field[7-9]$'}), TEST_DEFAULTS)
+    assert_equal true, d.match?('field0')
+    assert_equal true, d.match?('field1')
+    assert ! d.match?('field7')
+    assert ! d.match?('field8')
+    assert ! d.match?('field9')
+  end
+
+  def test_check_numeric
+    t = Time.strptime('2012-07-19 14:40:30', '%Y-%m-%d %T')
+    d = Fluent::NotifierOutput::Definition.new(TEST_CONF1, TEST_DEFAULTS)
+    r = d.check('test.tag', t.to_i, {'field1' => '0.8', 'field2' => '1.5'}, 'field1')
+    assert_nil r
+
+    r = d.check('test.tag', t.to_i, {'field1' => '0.8', 'field2' => '1.5'}, 'field2')
+    assert_equal "name1\ttest.tag\tfield2", r[:hashkey]
+    assert_equal d, r[:match_def]
+    assert_equal 'notify', r[:emit_tag]
+    assert_equal 'name1', r['pattern']
+    assert_equal 'test.tag', r['target_tag']
+    assert_equal 'field2', r['target_key']
+    assert_equal 'numeric_upward', r['check_type']
+    assert_equal 'warn', r['level']
+    assert_equal 1.0, r['threshold']
+    assert_equal 1.5, r['value']
+    assert_equal t.to_s, r['message_time']
+
+    r = d.check('test.tag', t.to_i, {'field1' => '200', 'field2' => '1.5'}, 'field1')
+    assert_equal "name1\ttest.tag\tfield1", r[:hashkey]
+    assert_equal d, r[:match_def]
+    assert_equal 'notify', r[:emit_tag]
+    assert_equal 'name1', r['pattern']
+    assert_equal 'test.tag', r['target_tag']
+    assert_equal 'field1', r['target_key']
+    assert_equal 'numeric_upward', r['check_type']
+    assert_equal 'crit', r['level']
+    assert_equal 2.0, r['threshold']
+    assert_equal 200.0, r['value']
+    assert_equal t.to_s, r['message_time']
+  end
+
+  def test_check_string
+    t = Time.strptime('2012-07-19 14:40:30', '%Y-%m-%d %T')
+    d = Fluent::NotifierOutput::Definition.new(TEST_CONF2, TEST_DEFAULTS)
+    r = d.check('test.tag', t.to_i, {'field0' => 'hoge pos', 'field1' => 'CRIT fooooooo baaaaarrrrrrr'}, 'field0')
+    assert_nil r
+
+    r = d.check('test.tag', t.to_i, {'field0' => 'hoge pos', 'field1' => 'CRIT fooooooo baaaaarrrrrrr'}, 'field1')
+    assert_equal "name2\ttest.tag\tfield1", r[:hashkey]
+    assert_equal d, r[:match_def]
+    assert_equal 'crit', r[:emit_tag]
+    assert_equal 'name2', r['pattern']
+    assert_equal 'test.tag', r['target_tag']
+    assert_equal 'field1', r['target_key']
+    assert_equal 'string_find', r['check_type']
+    assert_equal 'crit', r['level']
+    assert_equal '/CRIT/', r['regexp']
+    assert_equal 'CRIT fooooooo baaaaarrrrrrr', r['value']
+    assert_equal t.to_s, r['message_time']
+
+    r = d.check('test.tag', t.to_i, {'field0' => 'hoge pos (WARN) check!', 'field1' => 'CRIT fooooooo baaaaarrrrrrr'}, 'field0')
+    assert_equal "name2\ttest.tag\tfield0", r[:hashkey]
+    assert_equal d, r[:match_def]
+    assert_equal 'warn', r[:emit_tag]
+    assert_equal 'name2', r['pattern']
+    assert_equal 'test.tag', r['target_tag']
+    assert_equal 'field0', r['target_key']
+    assert_equal 'string_find', r['check_type']
+    assert_equal 'warn', r['level']
+    assert_equal '/WARN/', r['regexp']
+    assert_equal 'hoge pos (WARN) check!', r['value']
+    assert_equal t.to_s, r['message_time']
+  end
+end

data/test/plugin/test_out_notifier.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class NotifierOutputTest < Test::Unit::TestCase
+  CONFIG = %[
+]
+  def create_driver(conf=CONFIG,tag='test')
+    Fluent::Test::OutputTestDriver.new(Fluent::NotifierOutput, tag).configure(conf)
+  end
+end

data/test/plugin/test_state.rb

@@ -0,0 +1,76 @@
+require 'helper'
+
+class NotifierOutputStateTest < Test::Unit::TestCase
+  TEST_DEF_DEFAULTS = {
+    :tag => 'n', :tag_warn => nil, :tag_crit => nil,
+    :interval_1st => 60, :repetitions_1st => 5,
+    :interval_2nd => 300, :repetitions_2nd => 5,
+    :interval_3rd => 1800
+  }
+  TEST_DEF_CONF1 = {
+    'tag' => 'notify',
+    'pattern' => 'name1', 'target_keys' => 'field1,field2',
+    'check' => 'numeric_upward', 'warn_threshold' => '1', 'crit_threshold' => '2',
+  }
+  TEST_DEF_CONF2 = {
+    'tag_warn' => 'warn', 'tag_crit' => 'crit',
+    'pattern' => 'name2', 'target_key_pattern' => '^field\d$',
+    'check' => 'string_find', 'warn_regexp' => 'WARN', 'crit_regexp' => 'CRIT',
+    'interval_1st' => 5, 'repetitions_1st' => 1,
+    'interval_2nd' => 6, 'repetitions_2nd' => 2,
+    'interval_3rd' => 7
+  }
+
+  def test_init
+    s = Fluent::NotifierOutput::State.new({
+        :pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'
+      })
+    assert_equal 'name1', s.pattern
+    assert_equal 'test.tag', s.target_tag
+    assert_equal 'field1', s.target_key
+    assert_equal 'warn', s.level
+    assert_equal 0, s.stage
+    assert_equal 1, s.counter
+    assert (s.first_notified <= Fluent::Engine.now)
+    assert (s.last_notified <= Fluent::Engine.now)
+  end
+
+  def test_suppress?
+    s = Fluent::NotifierOutput::State.new({
+        :pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'
+      })
+    d = Fluent::NotifierOutput::Definition.new(TEST_DEF_CONF1, TEST_DEF_DEFAULTS)
+    s.last_notified = Fluent::Engine.now - TEST_DEF_DEFAULTS[:interval_1st] + 5
+    assert_equal true, s.suppress?(d, {:pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'})
+    s.last_notified = Fluent::Engine.now - TEST_DEF_DEFAULTS[:interval_1st] - 5
+    assert_equal false, s.suppress?(d, {:pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'})
+
+    s = Fluent::NotifierOutput::State.new({
+        :pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'
+      })
+    d = Fluent::NotifierOutput::Definition.new(TEST_DEF_CONF1, TEST_DEF_DEFAULTS)
+    assert_equal true, s.suppress?(d, {:pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'crit'})
+  end
+
+  def test_update_notified
+    s = Fluent::NotifierOutput::State.new({
+        :pattern => 'name2', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'
+      })
+    d = Fluent::NotifierOutput::Definition.new(TEST_DEF_CONF2, TEST_DEF_DEFAULTS)
+
+    assert_equal 0, s.stage
+    assert_equal 1, s.counter
+
+    s.update_notified(d, {:pattern => 'name2', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'})
+    assert_equal 1, s.stage
+    assert_equal 0, s.counter
+    
+    s.update_notified(d, {:pattern => 'name2', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'})
+    assert_equal 1, s.stage
+    assert_equal 1, s.counter
+
+    s.update_notified(d, {:pattern => 'name2', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'crit'})
+    assert_equal 0, s.stage
+    assert_equal 1, s.counter
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-notifier
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-18 00:00:00.000000000 Z
+date: 2012-07-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: fluentd
   requirement: !ruby/object:Gem::Requirement
@@ -58,7 +74,9 @@ files:
 - fluent-plugin-notifier.gemspec
 - lib/fluent/plugin/out_notifier.rb
 - test/helper.rb
+- test/plugin/test_def.rb
 - test/plugin/test_out_notifier.rb
+- test/plugin/test_state.rb
 homepage: https://github.com/tagomoris/fluent-plugin-notifier
 licenses: []
 post_install_message: 
@@ -85,4 +103,6 @@ specification_version: 3
 summary: check matched messages and emit alert message
 test_files:
 - test/helper.rb
+- test/plugin/test_def.rb
 - test/plugin/test_out_notifier.rb
+- test/plugin/test_state.rb