fluent-plugin-flowcounter-simple 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ea1531a6eca03db802d05acb32f7ac39cfd29576
-  data.tar.gz: 6db938ffaa1c09dc074816b6491fc8dfa752b9f1
+SHA256:
+  metadata.gz: 4f4d2e85abdbdf5c7b9e3bca8de7740066e6337262216bb09d7cd93e668c5977
+  data.tar.gz: beef12e960f130d3c1710d63e346c7524d410224e1548fc4c3bcc38643ed1ed8
 SHA512:
-  metadata.gz: 3564af10781be5858eed85223f0657581a7140e729d994fba324bbb0222532d524408a1821182352316657f73f01182254daa62cad3e5de94257ace2b96e7939
-  data.tar.gz: 7b327631a4d0cb1a082d26e0bebb3674549cf4b37184de7057993d942181d1e26d44c6481934d4272235758869383e192d71237cc582e860595535e5e8a0a8ce
+  metadata.gz: cb0cddb0135a5e1b8013d93490edcc872af9f2fe4d4f39206155704f00807a16a0b904e8bb3a5ad4049cdb8c5e81ecfc72bc8ffb581c6709abfcf4a1b64677fc
+  data.tar.gz: a1f1b6b1450ebae1c6269232924acb9769367dd13f31a4fa176ced494168f4aa6c42769f448247b15499195fbf3c33e5c6e509b88b67448e1bfa30c351c420f0

data/.travis.yml

@@ -1,8 +1,11 @@
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 2.2
+  - 2.4.*
+  - 2.5.*
+  - 2.6.*
+  - 2.7.*
+
 gemfile:
   - Gemfile
-  - Gemfile.v0.10
+
+before_install:
+  - gem update bundler

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.1.0 (2020/06/30)
+
+* Use fluentd v1 API (repeatedly)
+
 ## 0.0.4 (2015/04/24)
 
 Enhancements:

data/README.md

@@ -2,21 +2,15 @@
 
 Simple Fluentd Plugin to count number of messages and outputs to log
 
-## Output Plugin Configuration
+## Requirements
 
-    <match foo.bar.**>
-      type flowcounter_simple
-      unit second
-    </match>
-
-This plugin does not emit, just writes counts into the log file as
-
-    plugin:out_flowcounter_simple  count:30  indicator:num  unit:second
+| fluent-plugin-flowcounter-simple  | fluentd | ruby |
+|-------------------|---------|------|
+| >= 0.1.0 | >= v1.0 | >= 2.4 |
+|  < 0.0.4 | >= v0.12.0 | >= 2.1 |
 
 ## Filter Plugin Configuration
 
-Fluentd >= v0.12
-
 ```apache
 <filter foo.bar.**>
   type flowcounter_simple
@@ -28,6 +22,17 @@ This filter plugin pass through records, and writes counts into the log file as
 
     plugin:out_flowcounter_simple  count:30  indicator:num  unit:second
 
+## Output Plugin Configuration
+
+    <match foo.bar.**>
+      type flowcounter_simple
+      unit second
+    </match>
+
+This plugin does not emit, just writes counts into the log file as
+
+    plugin:out_flowcounter_simple  count:30  indicator:num  unit:second
+
 ## Parameters
 
 - unit

data/fluent-plugin-flowcounter-simple.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |gem|
   gem.name        = "fluent-plugin-flowcounter-simple"
-  gem.version     = "0.0.4"
+  gem.version     = "0.1.0"
   gem.authors     = ["Naotoshi Seo"]
   gem.email       = ["sonots@gmail.com"]
   gem.summary     = %q{Simple Fluentd Plugin to count number of messages and outputs to log}
@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_runtime_dependency "fluentd"
+  gem.add_runtime_dependency "fluentd", [">= 1.0"]
   gem.add_development_dependency "rake"
   gem.add_development_dependency "pry"
   gem.add_development_dependency "pry-nav"

data/lib/fluent/plugin/filter_flowcounter_simple.rb

@@ -1,21 +1,15 @@
-# I'm lazy to to implement filter plugin. Use output plugin instance
-require_relative 'out_flowcounter_simple'
-require 'forwardable'
+require 'fluent/plugin/filter'
+require_relative 'flowcounter_simple'
 
-class Fluent::FlowCounterSimpleFilter < Fluent::Filter
-  Fluent::Plugin.register_filter('flowcounter_simple', self)
+module Fluent::Plugin
+  class FlowCounterSimpleFilter < Filter
+    Fluent::Plugin.register_filter('flowcounter_simple', self)
 
-  extend Forwardable
-  attr_reader :output
-  def_delegators :@output, :configure, :start, :shutdown, :flush_emit
+    include ::Fluent::FlowcounterSimple
 
-  def initialize
-    super
-    @output = Fluent::FlowCounterSimpleOutput.new
+    def filter_stream(tag, es)
+      process_count(tag, es)
+      es
+    end
   end
-
-  def filter_stream(tag, es)
-    @output.emit(tag, es, Fluent::NullOutputChain.instance)
-    es
-  end
-end if defined?(Fluent::Filter)
+end

data/lib/fluent/plugin/flowcounter_simple.rb

@@ -0,0 +1,100 @@
+require 'fluent/plugin_helper/thread'
+
+module Fluent
+  module FlowcounterSimple
+    attr_accessor :last_checked
+
+    def self.included(klass)
+      klass.helpers :thread
+      klass.config_param :indicator, :string, :default => 'num'
+      klass.config_param :unit, :string, :default => 'second'
+      klass.config_param :comment, :string, :default => nil
+    end
+
+    def configure(conf)
+      super
+
+      @indicator_proc =
+        case @indicator
+        when 'num'  then Proc.new { |es| es.size }
+        when 'byte' then Proc.new { |es|
+                           count = 0
+                           es.each { |time, record|
+                             count += record.to_msgpack.size
+                           }
+                           count
+                         }
+        else
+          raise Fluent::ConfigError, "flowcounter-simple count allows num/byte"
+        end
+      @unit =
+        case @unit
+        when 'second' then :second
+        when 'minute' then :minute
+        when 'hour' then :hour
+        when 'day' then :day
+        else
+          raise Fluent::ConfigError, "flowcounter-simple unit allows second/minute/hour/day"
+        end
+      @tick =
+        case @unit
+        when :second then 1
+        when :minute then 60
+        when :hour then 3600
+        when :day then 86400
+        else
+          raise Fluent::ConfigError, "@unit must be one of second/minute/hour/day"
+        end
+
+      @type_str = self.is_a?(Fluent::Plugin::Filter) ? 'filter' : 'out'
+      @output_proc =
+        if @comment
+          Proc.new { |count| "plugin:#{@type_str}_flowcounter_simple\tcount:#{count}\tindicator:#{@indicator}\tunit:#{@unit}\tcomment:#{@comment}" }
+        else
+          Proc.new { |count| "plugin:#{@type_str}_flowcounter_simple\tcount:#{count}\tindicator:#{@indicator}\tunit:#{@unit}" }
+        end
+
+      @count = 0
+      @mutex = Mutex.new
+    end
+
+    def start
+      super
+      thread_create(:flowcounter_simple_watch, &method(:watch))
+    end
+
+    def shutdown
+      super
+    end
+
+    def countup(count)
+      @mutex.synchronize {
+        @count = (@count || 0) + count
+      }
+    end
+
+    def flush_emit(step)
+      count, @count = @count, 0
+      if count > 0
+        log.info @output_proc.call(count)
+      end
+    end
+
+    def watch
+      # instance variable, and public accessable, for test
+      @last_checked = Fluent::EventTime.now
+      while thread_current_running?
+        sleep 0.1
+        if Fluent::EventTime.now - @last_checked >= @tick
+          now = Fluent::EventTime.now
+          flush_emit(now - @last_checked)
+          @last_checked = now
+        end
+      end
+    end
+
+    def process_count(tag, es)
+      countup(@indicator_proc.call(es))
+    end
+  end
+end

data/lib/fluent/plugin/out_flowcounter_simple.rb

@@ -1,106 +1,22 @@
-class Fluent::FlowCounterSimpleOutput < Fluent::Output
-  Fluent::Plugin.register_output('flowcounter_simple', self)
+require 'fluent/plugin/output'
+require_relative 'flowcounter_simple'
 
-  # To support log_level option implemented by Fluentd v0.10.43
-  unless method_defined?(:log)
-    define_method("log") { $log }
-  end
-
-  config_param :indicator, :string, :default => 'num'
-  config_param :unit, :string, :default => 'second'
-  config_param :comment, :string, :default => nil
-
-  attr_accessor :last_checked
-
-  def configure(conf)
-    super
-
-    @indicator_proc =
-      case @indicator
-      when 'num'  then Proc.new {|record| 1 }
-      when 'byte' then Proc.new {|record| record.to_msgpack.size }
-      else
-        raise Fluent::ConfigError, "flowcounter-simple count allows num/byte"
-      end
-    @unit =
-      case @unit
-      when 'second' then :second
-      when 'minute' then :minute
-      when 'hour' then :hour
-      when 'day' then :day
-      else
-        raise Fluent::ConfigError, "flowcounter-simple unit allows second/minute/hour/day"
-      end
-    @tick =
-      case @unit
-      when :second then 1
-      when :minute then 60
-      when :hour then 3600
-      when :day then 86400
-      else
-        raise RuntimeError, "@unit must be one of second/minute/hour/day"
-      end
+module Fluent::Plugin
+  class FlowCounterSimpleOutput < Output
+    Fluent::Plugin.register_output('flowcounter_simple', self)
 
-    @output_proc =
-      if @comment
-        Proc.new {|count| "plugin:out_flowcounter_simple\tcount:#{count}\tindicator:#{@indicator}\tunit:#{@unit}\tcomment:#{@comment}" }
-      else
-        Proc.new {|count| "plugin:out_flowcounter_simple\tcount:#{count}\tindicator:#{@indicator}\tunit:#{@unit}" }
-      end
+    include ::Fluent::FlowcounterSimple
 
-    @count = 0
-    @mutex = Mutex.new
-  end
-
-  def start
-    super
-    start_watch
-  end
-
-  def shutdown
-    super
-    @watcher.terminate
-    @watcher.join
-  end
-
-  def countup(count)
-    @mutex.synchronize {
-      @count = (@count || 0) + count
-    }
-  end
-
-  def flush_emit(step)
-    count, @count = @count, 0
-    if count > 0
-      log.info @output_proc.call(count)
+    def prefer_buffered_processing
+      false
     end
-  end
 
-  def start_watch
-    # for internal, or tests only
-    @watcher = Thread.new(&method(:watch))
-  end
-
-  def watch
-    # instance variable, and public accessable, for test
-    @last_checked = Fluent::Engine.now
-    while true
-      sleep 0.1
-      if Fluent::Engine.now - @last_checked >= @tick
-        now = Fluent::Engine.now
-        flush_emit(now - @last_checked)
-        @last_checked = now
-      end
+    def multi_workers_ready?
+      true
     end
-  end
 
-  def emit(tag, es, chain)
-    count = 0
-    es.each {|time,record|
-      count += @indicator_proc.call(record)
-    }
-    countup(count)
-
-    chain.next
+    def process(tag, es)
+      process_count(tag, es)
+    end
   end
 end

data/test/helper.rb

@@ -1,27 +1,28 @@
 require 'rubygems'
 require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
+
 require 'test/unit'
+require 'test/unit/rr'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
+
 require 'fluent/test'
-require 'fluent/plugin/out_flowcounter_simple'
-require 'fluent/plugin/filter_flowcounter_simple'
 
 class Test::Unit::TestCase
   def capture_log(log)
-    tmp = log.out
-    log.out = StringIO.new
-    yield
-    return log.out.string
-  ensure
-    log.out = tmp
+    if defined?(Fluent::Test::TestLogger) and log.is_a?(Fluent::Test::TestLogger) # v0.14
+      yield
+      log.out.logs.join("\n")
+    else
+      begin
+        tmp = log.out
+        log.out = StringIO.new
+        yield
+        return log.out.string
+      ensure
+        log.out = tmp
+      end
+    end
   end
 end

data/test/plugin/test_filter_flowcounter_simple.rb

@@ -1,5 +1,6 @@
 require_relative '../helper'
-require "test/unit/rr"
+require 'fluent/test/driver/filter'
+require 'fluent/plugin/filter_flowcounter_simple'
 
 class FlowCounterSimpleFilterTest < Test::Unit::TestCase
   include Fluent
@@ -14,7 +15,7 @@ class FlowCounterSimpleFilterTest < Test::Unit::TestCase
   ]
 
   def create_driver(conf = CONFIG)
-    Fluent::Test::FilterTestDriver.new(Fluent::FlowCounterSimpleFilter).configure(conf, true)
+    Fluent::Test::Driver::Filter.new(Fluent::Plugin::FlowCounterSimpleFilter).configure(conf)
   end
 
   def test_filter
@@ -26,24 +27,20 @@ class FlowCounterSimpleFilterTest < Test::Unit::TestCase
     d = create_driver
     filtered, out = filter(d, msgs)
     assert_equal msgs, filtered
-    assert( out.include?("count:20"), out )
+    assert { out.include?("count:20") }
   end
 
   private
 
   def filter(d,  msgs)
-    stub(d.instance.output).start
-    stub(d.instance.output).shutdown
-    d.run {
+    d.run(default_tag: 'test') {
       msgs.each {|msg|
-        d.filter(msg, @time)
+        d.feed(msg)
       }
     }
-    out = capture_log(d.instance.output.log) do
+    out = capture_log(d.instance.log) do
       d.instance.flush_emit(0)
     end
-    filtered = d.filtered_as_array
-    filtered_msgs = filtered.map {|m| m[2] }
-    [filtered_msgs, out]
+    [d.filtered_records, out]
   end
-end if defined?(Fluent::Filter)
+end

data/test/plugin/test_out_flowcounter_simple.rb

@@ -1,4 +1,6 @@
 require_relative '../helper'
+require 'fluent/test/driver/output'
+require 'fluent/plugin/out_flowcounter_simple'
 
 class FlowCounterSimpleOutputTest < Test::Unit::TestCase
   def setup
@@ -10,60 +12,60 @@ class FlowCounterSimpleOutputTest < Test::Unit::TestCase
   ]
 
   def create_driver(conf=CONFIG,tag='test')
-    Fluent::Test::OutputTestDriver.new(Fluent::FlowCounterSimpleOutput, tag).configure(conf)
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::FlowCounterSimpleOutput).configure(conf)
   end
 
   def test_configure
     assert_nothing_raised {
-      d = create_driver('')
+      create_driver('')
     }
     assert_nothing_raised {
-      d = create_driver(CONFIG)
+      create_driver(CONFIG)
     }
     assert_nothing_raised {
-      d = create_driver(CONFIG + %[indicator num])
+      create_driver(CONFIG + %[indicator num])
     }
     assert_nothing_raised {
-      d = create_driver(CONFIG + %[indicator byte])
+      create_driver(CONFIG + %[indicator byte])
     }
   end
 
   def test_num
-    d1 = create_driver(CONFIG, 'test.tag1')
-    d1.run do
+    d1 = create_driver(CONFIG)
+    d1.run(default_tag: 'test.tag1') do
       10.times do
-        d1.emit({'message'=> 'a' * 100})
-        d1.emit({'message'=> 'b' * 100})
-        d1.emit({'message'=> 'c' * 100})
+        d1.feed({'message'=> 'a' * 100})
+        d1.feed({'message'=> 'b' * 100})
+        d1.feed({'message'=> 'c' * 100})
       end
     end
     out = capture_log(d1.instance.log) { d1.instance.flush_emit(60) }
-    assert( out.include?("count:30"), out )
+    assert { out.include?("count:30") }
   end
 
   def test_byte
-    d1 = create_driver(CONFIG + %[indicator byte], 'test.tag1')
-    d1.run do
+    d1 = create_driver(CONFIG + %[indicator byte])
+    d1.run(default_tag: 'test.tag1') do
       10.times do
-        d1.emit({'message'=> 'a' * 100})
-        d1.emit({'message'=> 'b' * 100})
-        d1.emit({'message'=> 'c' * 100})
+        d1.feed({'message'=> 'a' * 100})
+        d1.feed({'message'=> 'b' * 100})
+        d1.feed({'message'=> 'c' * 100})
       end
     end
     out = capture_log(d1.instance.log) { d1.instance.flush_emit(60) }
-    assert( out.include?("count:3360"), out )
+    assert { out =~ /count:\d+\tindicator:byte\tunit:second/ }
   end
 
   def test_comment
-    d1 = create_driver(CONFIG + %[comment foobar], 'test.tag1')
-    d1.run do
+    d1 = create_driver(CONFIG + %[comment foobar])
+    d1.run(default_tag: 'test.tag1') do
       1.times do
-        d1.emit({'message'=> 'a' * 100})
-        d1.emit({'message'=> 'b' * 100})
-        d1.emit({'message'=> 'c' * 100})
+        d1.feed({'message'=> 'a' * 100})
+        d1.feed({'message'=> 'b' * 100})
+        d1.feed({'message'=> 'c' * 100})
       end
     end
     out = capture_log(d1.instance.log) { d1.instance.flush_emit(60) }
-    assert( out.include?("comment:foobar"), out )
+    assert { out.include?("comment:foobar") }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-flowcounter-simple
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Naotoshi Seo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-23 00:00:00.000000000 Z
+date: 2020-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -105,7 +105,6 @@ files:
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
-- Gemfile.v0.10
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -113,6 +112,7 @@ files:
 - examples/output.conf
 - fluent-plugin-flowcounter-simple.gemspec
 - lib/fluent/plugin/filter_flowcounter_simple.rb
+- lib/fluent/plugin/flowcounter_simple.rb
 - lib/fluent/plugin/out_flowcounter_simple.rb
 - test/helper.rb
 - test/plugin/test_filter_flowcounter_simple.rb
@@ -136,8 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Simple Fluentd Plugin to count number of messages and outputs to log

data/Gemfile.v0.10

@@ -1,4 +0,0 @@
-source "http://rubygems.org"
-
-gemspec
-gem 'fluentd', '~> 0.10.0'