fluent-plugin-fork 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0dce65d094e236ecdfd6e71531876c6fb0ec1d0
-  data.tar.gz: d4d2923c986719fdab2afad5db7be8aac868fd82
+  metadata.gz: 396b07f3000837ee1b5857b7882e74891f3e4142
+  data.tar.gz: e5916c1b9cb4a13785872846e2078bc9a158511f
 SHA512:
-  metadata.gz: 396e2a955d81dc5afdd82a051426a817da5f8e2e4c54716f8cc74fa1dc556c04e7692e3f58d83182e20ffd8407b1e4f62e459c8fda006ac4f38cdc570e94b456
-  data.tar.gz: 97cdc9fde08efdbc683401a38016ffb8616250d7abce6d292d4cc9e58b2b89c6fda102cc64b2497ad7d19b410424465ce33e90a9fcd3b38616ee26c444a849b8
+  metadata.gz: e8dc76716c13d43aceefd791d32f988599dd0a98d33940e58ddaf6dc842be4e8df4792cf9ce52812d38dde9f0f9106f62c36b2e43ed67f7a8c5668970ce08c6b
+  data.tar.gz: 2e478c2e49328dead0aee9517c5c140279f35071b9adcb0c1fef5288404ac87acb93228ad4e64dd2cc6693afb4131862a8cb1e044a8ddf83c9a587b4ae960db8

data/.travis.yml

@@ -7,18 +7,9 @@ rvm:
   - 2.4.1
 gemfile:
   - gemfiles/gemfile
-  - gemfiles/fluentd.0.10.42.gemfile
 
 script: "bundle exec rake spec"
 
 branches:
   only:
     - master
-matrix:
-  exclude:
-    - rvm: 2.2
-      gemfile: gemfiles/fluentd.0.10.42.gemfile
-    - rvm: 2.3.4
-      gemfile: gemfiles/fluentd.0.10.42.gemfile
-    - rvm: 2.4.1
-      gemfile: gemfiles/fluentd.0.10.42.gemfile

data/README.md

@@ -20,6 +20,13 @@ to
 {"id": "1", "key": "2", "segments": "3"}
 ```
 
+## Requirements
+
+| fluent-plugin-fork | Fluentd          | Ruby   |
+|--------------------|------------------|--------|
+| >= 0.2.0           | >= v0.14, < v2.0 | >= 2.1 |
+| < 0.2.0            | <= v0.14         | >= 1.9 |
+
 ## Installation
 
 ### td-agent(Linux)

data/fluent-plugin-fork.gemspec

@@ -2,7 +2,7 @@ $:.push File.expand_path('../lib', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name        = "fluent-plugin-fork"
-  gem.version     = "0.1.5"
+  gem.version     = "0.2.0"
   gem.authors     = ["Daisuke Taniwaki"]
   gem.email       = "daisuketaniwaki@gmail.com"
   gem.homepage    = "https://github.com/dtaniwaki/fluent-plugin-fork"
@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.require_paths = ['lib']
 
-  gem.add_runtime_dependency "fluentd", [">= 0.10.0", "< 2"]
+  gem.add_runtime_dependency "fluentd", [">= 0.14.0", "< 2"]
   gem.add_development_dependency "rake"
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "coveralls"

data/lib/fluent/plugin/out_fork.rb

@@ -1,16 +1,12 @@
-module Fluent
+require 'fluent/plugin/output'
+
+module Fluent::Plugin
   class ForkOutput < Output
     class MaxForkSizeError < StandardError; end
 
     Fluent::Plugin.register_output('fork', self)
 
-    unless method_defined?(:log)
-      define_method(:log) { $log }
-    end
-
-    unless method_defined?(:router)
-      define_method(:router) { Fluent::Engine }
-    end
+    helpers :event_emitter
 
     def initialize
       super
@@ -33,7 +29,7 @@ module Fluent
       raise Fluent::ConfigError, "max_fallback must be one of #{fallbacks.inspect}" unless fallbacks.include?(@max_fallback)
     end
 
-    def emit(tag, es, chain)
+    def process(tag, es)
       es.each do |time, record|
         org_value = record[@fork_key]
         if org_value.nil?
@@ -76,8 +72,6 @@ module Fluent
       end
     rescue => e
       log.error "#{e.message}: #{e.backtrace.join(', ')}"
-    ensure
-      chain.next
     end
   end
 end

data/spec/plugin/out_fork_spec.rb

@@ -1,11 +1,13 @@
 require 'spec_helper'
 
-describe Fluent::ForkOutput do
+describe Fluent::Plugin::ForkOutput do
+  include Fluent::Test::Helpers
+
   let(:tag) { "test.fork" }
   let(:required_params) { {output_tag: 'ot', output_key: 'ok', fork_key: 'sk'} }
   let(:params) { required_params }
   let(:config) { params.map{ |k, v| "#{k} #{v}" }.join("\n") }
-  subject { Fluent::Test::OutputTestDriver.new(Fluent::ForkOutput, tag).configure(config) }
+  subject { Fluent::Test::Driver::Output.new(Fluent::Plugin::ForkOutput).configure(config) }
 
   describe "#configure" do
     let(:params) { required_params.merge(separator: '-', max_size: 5, max_fallback: 'drop', no_unique: true) }
@@ -50,59 +52,59 @@ describe Fluent::ForkOutput do
   end
 
   describe "#run" do
-    let(:time) { Time.now.to_i }
+    let(:time) { event_time }
     it "forks" do
-      subject.run { subject.emit({"sk" => "2,3,4,5"}, time) }
-      expect(subject.emits.size).to eq(4)
-      expect(subject.emits).to include(["ot", time, {"ok" => "2"}])
-      expect(subject.emits).to include(["ot", time, {"ok" => "3"}])
-      expect(subject.emits).to include(["ot", time, {"ok" => "4"}])
-      expect(subject.emits).to include(["ot", time, {"ok" => "5"}])
+      subject.run(default_tag: tag) { subject.feed(time, {"sk" => "2,3,4,5"}) }
+      expect(subject.events.size).to eq(4)
+      expect(subject.events).to include(["ot", time, {"ok" => "2"}])
+      expect(subject.events).to include(["ot", time, {"ok" => "3"}])
+      expect(subject.events).to include(["ot", time, {"ok" => "4"}])
+      expect(subject.events).to include(["ot", time, {"ok" => "5"}])
     end
     it "forks uniquely" do
-      subject.run { subject.emit({"sk" => "2,3,4,3"}, time) }
-      expect(subject.emits.size).to eq(3)
-      expect(subject.emits).to include(["ot", time, {"ok" => "2"}])
-      expect(subject.emits).to include(["ot", time, {"ok" => "3"}])
-      expect(subject.emits).to include(["ot", time, {"ok" => "4"}])
+      subject.run(default_tag: tag) { subject.feed(time, {"sk" => "2,3,4,3"}) }
+      expect(subject.event_streams.size).to eq(3)
+      expect(subject.events).to include(["ot", time, {"ok" => "2"}])
+      expect(subject.events).to include(["ot", time, {"ok" => "3"}])
+      expect(subject.events).to include(["ot", time, {"ok" => "4"}])
     end
     it "forks with other params" do
-      subject.run { subject.emit({"sk" => "2,3,4,5", "o1" => 1, "o2" => 2}, time) }
-      expect(subject.emits.size).to eq(4)
-      expect(subject.emits).to include(["ot", time, {"ok" => "2", "o1" => 1, "o2" => 2}])
-      expect(subject.emits).to include(["ot", time, {"ok" => "3", "o1" => 1, "o2" => 2}])
-      expect(subject.emits).to include(["ot", time, {"ok" => "4", "o1" => 1, "o2" => 2}])
-      expect(subject.emits).to include(["ot", time, {"ok" => "5", "o1" => 1, "o2" => 2}])
+      subject.run(default_tag: tag) { subject.feed(time, {"sk" => "2,3,4,5", "o1" => 1, "o2" => 2}) }
+      expect(subject.events.size).to eq(4)
+      expect(subject.events).to include(["ot", time, {"ok" => "2", "o1" => 1, "o2" => 2}])
+      expect(subject.events).to include(["ot", time, {"ok" => "3", "o1" => 1, "o2" => 2}])
+      expect(subject.events).to include(["ot", time, {"ok" => "4", "o1" => 1, "o2" => 2}])
+      expect(subject.events).to include(["ot", time, {"ok" => "5", "o1" => 1, "o2" => 2}])
     end
     it "does nothing for empty value" do
-      subject.run { subject.emit({"o1" => 1, "o2" => 2}, time) }
-      expect(subject.emits.size).to eq(0)
+      subject.run(default_tag: tag) { subject.feed(time, {"o1" => 1, "o2" => 2}) }
+      expect(subject.events.size).to eq(0)
     end
     it "ignores exceptions and writes down the log" do
       expect(subject.instance.log).to receive(:error).with(/^The error/)
       allow_any_instance_of(String).to receive(:split).and_raise("The error")
-      subject.emit({"sk" => "2,3,4,5", "o1" => 1, "o2" => 2}, time)
+      subject.run(default_tag: tag) { subject.feed(time, {"sk" => "2,3,4,5", "o1" => 1, "o2" => 2}) }
     end
     context "with no_unique option" do
       let(:params) { required_params.merge(no_unique: true) }
       it "forks for redundant values" do
-        subject.run { subject.emit({"sk" => "2,3,4,3"}, time) }
-        expect(subject.emits.size).to eq(4)
-        expect(subject.emits).to include(["ot", time, {"ok" => "2"}])
-        expect(subject.emits).to include(["ot", time, {"ok" => "3"}])
-        expect(subject.emits).to include(["ot", time, {"ok" => "4"}])
-        expect(subject.emits).to include(["ot", time, {"ok" => "3"}])
+        subject.run(default_tag: tag) { subject.feed(time, {"sk" => "2,3,4,3"}) }
+        expect(subject.events.size).to eq(4)
+        expect(subject.events).to include(["ot", time, {"ok" => "2"}])
+        expect(subject.events).to include(["ot", time, {"ok" => "3"}])
+        expect(subject.events).to include(["ot", time, {"ok" => "4"}])
+        expect(subject.events).to include(["ot", time, {"ok" => "3"}])
       end
     end
     context "with separator option" do
       let(:params) { required_params.merge(separator: '-') }
       it "forks by separating with '-'" do
-        subject.run { subject.emit({"sk" => "2-3-4-5"}, time) }
-        expect(subject.emits.size).to eq(4)
-        expect(subject.emits).to include(["ot", time, {"ok" => "2"}])
-        expect(subject.emits).to include(["ot", time, {"ok" => "3"}])
-        expect(subject.emits).to include(["ot", time, {"ok" => "4"}])
-        expect(subject.emits).to include(["ot", time, {"ok" => "5"}])
+        subject.run(default_tag: tag) { subject.feed(time, {"sk" => "2-3-4-5"}) }
+        expect(subject.events.size).to eq(4)
+        expect(subject.events).to include(["ot", time, {"ok" => "2"}])
+        expect(subject.events).to include(["ot", time, {"ok" => "3"}])
+        expect(subject.events).to include(["ot", time, {"ok" => "4"}])
+        expect(subject.events).to include(["ot", time, {"ok" => "5"}])
       end
     end
     context "with max_size and max_fallback options" do
@@ -110,35 +112,35 @@ describe Fluent::ForkOutput do
         let(:params) { required_params.merge(max_size: 3, max_fallback: 'log') }
         it "writes a log" do
           expect(subject.instance.log).to receive(:info).with(/Too many forked values/)
-          subject.run { subject.emit({"sk" => "2,3,4,5"}, time) }
+          subject.run(default_tag: required_params[:output_tag]) { subject.feed(time, {"sk" => "2,3,4,5"}) }
         end
       end
       describe "drop" do
         let(:params) { required_params.merge(max_size: 3, max_fallback: 'drop') }
         it "drops exceeded values" do
-          subject.run { subject.emit({"sk" => "2,3,4,5"}, time) }
-          expect(subject.emits.size).to eq(3)
-          expect(subject.emits).to include(["ot", time, {"ok" => "2"}])
-          expect(subject.emits).to include(["ot", time, {"ok" => "3"}])
-          expect(subject.emits).to include(["ot", time, {"ok" => "4"}])
+          subject.run(default_tag: tag) { subject.feed(time, {"sk" => "2,3,4,5"}) }
+          expect(subject.events.size).to eq(3)
+          expect(subject.events).to include(["ot", time, {"ok" => "2"}])
+          expect(subject.events).to include(["ot", time, {"ok" => "3"}])
+          expect(subject.events).to include(["ot", time, {"ok" => "4"}])
         end
       end
       describe "skip" do
         let(:params) { required_params.merge(max_size: 3, max_fallback: 'skip') }
         it "skip the values" do
-          subject.run { subject.emit({"sk" => "2,3,4,5"}, time) }
-          expect(subject.emits.size).to eq(0)
+          subject.run(default_tag: tag) { subject.feed(time, {"sk" => "2,3,4,5"}) }
+          expect(subject.events.size).to eq(0)
         end
       end
     end
     context "with index_key option" do
       let(:params) { required_params.merge(index_key: 'idx') }
       it "add index number" do
-        subject.run { subject.emit({"sk" => "2,3,4,5"}, time) }
-        expect(subject.emits).to include(["ot", time, {"ok" => "2", "idx" => 0}])
-        expect(subject.emits).to include(["ot", time, {"ok" => "3", "idx" => 1}])
-        expect(subject.emits).to include(["ot", time, {"ok" => "4", "idx" => 2}])
-        expect(subject.emits).to include(["ot", time, {"ok" => "5", "idx" => 3}])
+        subject.run(default_tag: tag) { subject.feed(time, {"sk" => "2,3,4,5"}) }
+        expect(subject.events).to include(["ot", time, {"ok" => "2", "idx" => 0}])
+        expect(subject.events).to include(["ot", time, {"ok" => "3", "idx" => 1}])
+        expect(subject.events).to include(["ot", time, {"ok" => "4", "idx" => 2}])
+        expect(subject.events).to include(["ot", time, {"ok" => "5", "idx" => 3}])
       end
     end
   end

data/spec/spec_helper.rb

@@ -3,6 +3,8 @@ require 'coveralls'
 Coveralls.wear!
 
 require 'fluent/test'
+require 'fluent/test/driver/output'
+require 'fluent/test/helpers'
 require 'fluent/plugin/out_fork'
 
 RSpec.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-fork
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Daisuke Taniwaki
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.14.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.14.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -99,7 +99,6 @@ files:
 - README.md
 - Rakefile
 - fluent-plugin-fork.gemspec
-- gemfiles/fluentd.0.10.42.gemfile
 - gemfiles/gemfile
 - lib/fluent/plugin/out_fork.rb
 - spec/plugin/out_fork_spec.rb

data/gemfiles/fluentd.0.10.42.gemfile

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