fluent-plugin-sixpack 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7de3147cdbfecd0b93439d12c370b6db923dcbcc
+  data.tar.gz: cab2e034439051a97ce950949801cf70b3a159f3
+SHA512:
+  metadata.gz: 68cdd62f01db47a775f91ef2ed17e8b1137e05933aa8bbaa55d9934c85963fed5ccb73b171db2ca733d067dccbac78f6dea20d3b09f0623d1bbff00df95eab4c
+  data.tar.gz: 89f4a0ef7f4f3271f5aca1e8d82df38dc6d0f7b882e8d5222ad4c6ec982c325d766a153d43db3975a2270cbb0e02e49214a5849f1624086f239fe0bc0b3dff31

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,52 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+.DS_Store
+
+# For TextMate
+*.tmproj
+tmtags
+
+# For emacs:
+*~
+\#*
+.\#*
+
+# For vim:
+*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc
+
+Gemfile.lock
+vendor
+

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0

data/AUTHORS

@@ -0,0 +1,2 @@
+Naoki AINOYA     <ainonic _at_ gmail.com>
+TAGOMORI Satoshi <tagomoris _at_ gmail.com>

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fluent-plugin-sixpack.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright (c) 2012- Naoki AINOYA, TAGOMORI Satoshi
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,119 @@
+# fluent-plugin-sixpack
+
+## SixpackOutput
+
+[![Build Status](https://travis-ci.org/ainoya/fluent-plugin-sixpack.svg?branch=master)](https://travis-ci.org/ainoya/fluent-plugin-sixpack)
+
+[Fluentd](http://fluentd.org) plugin to execute A/B testing with application log.
+
+To get A/B test statistics, this plugin forwards logs to Sixpack server.
+
+About Sixpack, see:
+* Github: https://github.com/seatgeek/sixpack
+* Product site: http://sixpack.seatgeek.com
+
+### Configuration
+
+For messages to participate A/B test such as:
+
+    tag:your.arbitrary.tag {"record_type":"participate", "experiment":"header-color", "alternatives":"red,green,blue", "alternative":"red", "client_id":"ID-0000-0001"}
+
+Or messages to convert A/B test such as
+
+    tag:your.arbitrary.tag {"record_type":"convert", "experiment":"header-color", "client_id":"ID-0000-0001"}
+
+Configuration example for graphs in sixpack with POST api url `http://sixpack:5000/(participate|convert)`. You must set this parameter.
+
+    <match app.abtest.log>
+      type sixpack
+      sixpackapi_url http://sixpack.local:5000/
+    </match>
+
+With this configuration, out_sixpack posts urls below.
+
+## Parameters
+
+### Sixpack parameters
+
+You can change assignment between param keys and values, with using settings below.
+
+- `key_experiment, :default   => 'experiment'`
+- `key_alternatives, :default => 'alternatives'`
+- `key_alternative, :default  => 'alternative'`
+- `key_client_id, :default    => 'client_id'`
+- `key_record_type, :default  => 'record_type'`
+
+### Configuration parameters
+
+* background_post
+
+    Post to Sixpack in background thread, without retries for failures (Default: false)
+
+* timeout
+
+    Read/Write timeout seconds (Default: 60)
+
+* retry
+
+    Do retry for HTTP request failures, or not. This feature will be set as false for `background_post yes` automatically. (Default: true)
+
+* ssl
+
+    Use SSL (https) or not. Default is false.
+
+* verify\_ssl
+
+    Do SSL verification or not. Default is false (ignore the SSL verification).
+
+* authentication
+
+    Specify `basic` if your Sixpack protected with basic authentication. Default is 'none' (no authentication).
+
+* username
+
+    The username for authentication.
+
+* password
+
+    The password for authentication.
+
+## TODO
+
+* More Test
+* More Documents
+* Full compatibility with sixpack api
+
+## Contributing
+
+Once you've made your great commits:
+
+1. [Fork][fk] fluent-plugin-sixpack
+2. Create your feature branch (``git checkout -b my-new-feature``)
+3. Write tests
+4. Run tests with ``rake test``
+5. Commit your changes (``git commit -am 'Added some feature'``)
+6. Push to the branch (``git push origin my-new-feature``)
+7. Create new pull request
+8. That's it!
+
+Or, you can create an [Issue][is].
+
+## License
+
+### Copyright
+
+* Copyright (c) 2014- Naoki AINOYA
+* License
+  * Apache License, Version 2.0
+
+## Other Licence
+
+### Copyright of fluent-plugin-growthforecast
+
+This plugin implementation is based on [fluent-plugin-growthforecast](https://github.com/tagomoris/fluent-plugin-growthforecast).
+
+* Copyright (c) 2012- TAGOMORI Satoshi (tagomoris)
+* License
+  * Apache License, Version 2.0
+
+[fk]: http://help.github.com/forking/

data/Rakefile

@@ -0,0 +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/VERSION

@@ -0,0 +1 @@
+0.1.4

data/fluent-plugin-sixpack.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.name          = "fluent-plugin-sixpack"
+  gem.version       = "0.1.0"
+  gem.authors       = ["Naoki AINOYA"]
+  gem.email         = ["ainonic@gmail.com"]
+  gem.summary       = %q{Fluentd output plugin to post numbers to sixpack (by seatgeek)}
+  gem.description   = %q{For sixpack, see http://sixpack.seatgeek.com }
+  gem.homepage      = "https://github.com/ainoya/fluent-plugin-sixpack"
+  gem.license       = "APLv2"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake"
+  gem.add_runtime_dependency "fluentd"
+  gem.add_runtime_dependency "fluent-mixin-config-placeholders"
+  gem.add_runtime_dependency "resolve-hostname", ">= 0.0.4"
+end

data/lib/fluent/plugin/out_sixpack.rb

@@ -0,0 +1,250 @@
+class Fluent::SixpackOutput < Fluent::Output
+  Fluent::Plugin.register_output('sixpack', self)
+
+  def initialize
+    super
+    require 'net/http'
+    require 'uri'
+    require 'resolve/hostname'
+  end
+
+  config_param :sixpackapi_url, :string
+  config_param :key_experiment, :default   => 'experiment'
+  config_param :key_alternatives, :default => 'alternatives'
+  config_param :key_alternative, :default     => 'alternative'
+  config_param :key_client_id, :default    => 'client_id'
+  config_param :key_record_type, :default  => 'record_type'
+
+  config_param :user_agent, :default       => 'user_agent'
+  config_param :ip_address, :default       => 'ip_address'
+
+  config_param :ssl, :bool, :default => false
+  config_param :verify_ssl, :bool, :default => false
+
+  config_param :mode, :string, :default => 'gauge' # or count/modified
+
+  config_param :background_post, :bool, :default => false
+
+  config_param :timeout, :integer, :default => nil # default 60secs
+  config_param :retry, :bool, :default => true
+  config_param :keepalive, :bool, :default => true
+
+  config_param :authentication, :string, :default => nil # nil or 'none' or 'basic'
+  config_param :username, :string, :default => ''
+  config_param :password, :string, :default => ''
+
+  SIXPACK_PATH= {
+    :participate => '/participate',
+    :convert     => '/convert'
+  }
+
+  # Define `log` method for v0.10.42 or earlier
+  unless method_defined?(:log)
+    define_method("log") { $log }
+  end
+
+  def configure(conf)
+    super
+
+    @mode = case @mode
+            when 'count' then :count
+            when 'modified' then :modified
+            else
+              :gauge
+            end
+
+    @auth = case @authentication
+            when 'basic' then :basic
+            else
+              :none
+            end
+    @resolver = Resolve::Hostname.new(:system_resolver => true)
+  end
+
+  def start
+    super
+
+    @running = true
+    @thread = nil
+    @queue = nil
+    @mutex = nil
+    if @background_post
+      @mutex = Mutex.new
+      @queue = []
+      @thread = Thread.new(&method(:poster))
+    end
+  end
+
+  def shutdown
+    @running = false
+    @thread.join if @thread
+    super
+  end
+
+  def poster
+    while @running
+      if @queue.size < 1
+        sleep(0.2)
+        next
+      end
+
+      events = @mutex.synchronize {
+        es,@queue = @queue,[]
+        es
+      }
+      begin
+        post_events(events) if events.size > 0
+      rescue => e
+        log.warn "HTTP POST in background Error occures to sixpack server", :error_class => e.class, :error => e.message
+      end
+    end
+  end
+
+  def connect_to
+    url = URI.parse(@sixpackapi_url)
+    return url.host, url.port
+  end
+
+  def http_connection(host, port)
+    http = Net::HTTP.new(@resolver.getaddress(host), port)
+    if @timeout
+      http.open_timeout = @timeout
+      http.read_timeout = @timeout
+    end
+    if @ssl
+      http.use_ssl = true
+      unless @verify_ssl
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+    http
+  end
+
+  def map_sixpack_path(record)
+    sixpack_path
+  end
+
+  def map_sixpack_path_with_query(record)
+    sixpack_path = SIXPACK_PATH[record[@key_record_type].to_sym]
+    case record[@key_record_type]
+    when 'participate'
+      return sixpack_path, URI.encode_www_form({
+               :experiment   => record[@key_experiment],
+               :alternatives => record[@key_alternatives].split(','),
+               :alternative  => record[@key_alternative],
+               :client_id    => record[@key_client_id],
+             })
+    when 'convert'
+      return sixpack_path, URI.encode_www_form({
+               :experiment   => record[@key_experiment],
+               :client_id    => record[@key_client_id],
+             })
+    else
+      log.warn 'failed to map sixpack path and query'
+      raise
+    end
+  end
+
+  def post_request(event)
+    uri = URI.parse(@sixpackapi_url)
+    uri.path, uri.query = map_sixpack_path_with_query(event[:record])
+    req = Net::HTTP::Get.new(uri.request_uri)
+    if @auth and @auth == :basic
+      req.basic_auth(@username, @password)
+    end
+    req['Host'] = uri.host
+    if @keepalive
+      req['Connection'] = 'Keep-Alive'
+    end
+
+    req
+  end
+
+  def post(event)
+    url = @sixpackapi_url
+    res = nil
+    begin
+      host,port = connect_to
+      req = post_request(event)
+      http = http_connection(host, port)
+      res = http.start {|http| http.request(req) }
+    rescue IOError, EOFError, SystemCallError
+      # server didn't respond
+      log.warn "net/http GET raises exception: #{$!.class}, '#{$!.message}'"
+    end
+    unless res and res.is_a?(Net::HTTPSuccess)
+      log.warn "failed to post to sixpack #{url}, record#{event[:record]}, code: #{res && res.code}"
+    end
+  end
+
+  def post_keepalive(events) # [{:tag=>'',:name=>'',:value=>X}]
+    return if events.size < 1
+
+    # sixpack host/port is same for all events (host is from configuration)
+    host,port = connect_to
+
+    requests = events.map{|e| post_request(e)}
+
+    http = nil
+    requests.each do |req|
+      begin
+        unless http
+          http = http_connection(host, port)
+          http.start
+        end
+        res = http.request(req)
+        unless res and res.is_a?(Net::HTTPSuccess)
+          log.warn "failed to post to sixpack: #{host}:#{port}#{req.path}, post_data: #{req.body} code: #{res && res.code}"
+        end
+      rescue IOError, EOFError, Errno::ECONNRESET, Errno::ETIMEDOUT, SystemCallError
+        log.warn "net/http keepalive POST raises exception: #{$!.class}, '#{$!.message}'"
+        begin
+          http.finish
+        rescue
+          # ignore all errors for connection with error
+        end
+        http = nil
+      end
+    end
+    begin
+      http.finish
+    rescue
+      # ignore
+    end
+  end
+
+  def post_events(events)
+    if @keepalive
+      post_keepalive(events)
+    else
+      events.each do |event|
+        post(event)
+      end
+    end
+  end
+
+  def emit(tag, es, chain)
+    events = []
+
+    es.each {|time,record|
+      if SIXPACK_PATH.has_key?(record[@key_record_type].to_sym)
+        events.push({:time => time, :tag => tag, :record => record})
+      end
+    }
+
+    if @thread
+      @mutex.synchronize do
+        @queue += events
+      end
+    else
+      begin
+        post_events(events)
+      rescue => e
+        log.warn "HTTP POST Error occures to sixpack server", :error_class => e.class, :error => e.message
+        raise if @retry
+      end
+    end
+
+    chain.next
+  end
+end

data/test/helper.rb

@@ -0,0 +1,52 @@
+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'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'fluent/test'
+unless ENV.has_key?('VERBOSE')
+  nulllogger = Object.new
+  nulllogger.instance_eval {|obj|
+    def method_missing(method, *args)
+      # pass
+    end
+  }
+  $log = nulllogger
+end
+
+require 'fluent/plugin/out_sixpack'
+
+class Test::Unit::TestCase
+end
+
+require 'webrick'
+
+# to handle POST/PUT/DELETE ...
+module WEBrick::HTTPServlet
+  class ProcHandler < AbstractServlet
+    alias do_POST   do_GET
+    alias do_PUT    do_GET
+    alias do_DELETE do_GET
+  end
+end
+
+def get_code(server, port, path, headers={})
+  require 'net/http' 
+  Net::HTTP.start(server, port){|http|
+    http.get(path, headers).code
+  } 
+end 
+def get_content(server, port, path, headers={})
+  require 'net/http'
+  Net::HTTP.start(server, port){|http|
+    http.get(path, headers).body
+  } 
+end

data/test/plugin/test_out_growthforecast.rb

@@ -0,0 +1,273 @@
+require 'helper'
+
+class SixpackOutputTest < Test::Unit::TestCase
+  # setup/teardown and tests of dummy sixpack server defined at the end of this class...
+  SIXPACK_TEST_LISTEN_PORT = 5125
+
+  CONFIG_NON_KEEPALIVE = %[
+      sixpackapi_url http://127.0.0.1:#{SIXPACK_TEST_LISTEN_PORT}/
+      keepalive false
+  ]
+
+  CONFIG_THREADING_KEEPALIVE = %[
+      sixpackapi_url http://127.0.0.1:#{SIXPACK_TEST_LISTEN_PORT}/
+      background_post true
+      keepalive true
+      timeout   120
+  ]
+
+  CONFIG_THREADING_NON_KEEPALIVE = %[
+      sixpackapi_url http://127.0.0.1:#{SIXPACK_TEST_LISTEN_PORT}/
+      keepalive false
+  ]
+
+  def create_driver(conf=CONFIG_NON_KEEPALIVE, tag='test.metrics')
+    Fluent::Test::OutputTestDriver.new(Fluent::SixpackOutput, tag).configure(conf)
+  end
+
+  def test_convert
+    d = create_driver(CONFIG_NON_KEEPALIVE, 'test.metrics')
+    d.emit({'record_type' => 'convert',
+            'client_id'  => "0000-0000-0000-0000",
+            'experiment' => 'experiment_test_convert'})
+    sleep 0.5 # wait internal posting thread loop
+
+    assert_equal 1, @posted.size
+
+    assert_equal '0000-0000-0000-0000', @posted[0][:client_id]
+    assert_equal 'experiment_test_convert', @posted[0][:experiment]
+  end
+
+  def test_invalid_type
+    d = create_driver(CONFIG_NON_KEEPALIVE, 'test.metrics')
+    d.emit({'record_type' => 'invalid_type',
+            'client_id'  => "0000-0000-0000-0000",
+            'experiment' => 'experiment_test_invalid_type'})
+    sleep 0.5 # wait internal posting thread loop
+
+    assert_equal 0, @posted.size
+  end
+
+  def test_non_keepalive
+    d = create_driver(CONFIG_NON_KEEPALIVE, 'test.metrics')
+    ['red', 'blue', 'green'].each_with_index do |color, i|
+      d.emit({'record_type' => 'participate',
+             'alternatives' => 'red,blue,green',
+             'alternative'  =>  color,
+             'client_id'  => "0000-0000-0000-000#{i}",
+             'experiment' => 'experiment_test_threading_non_keepalive'})
+      sleep 0.5 # wait internal posting thread loop
+    end
+
+    assert_equal 3, @posted.size
+    v1st = @posted[0]
+    v2nd = @posted[1]
+    v3rd = @posted[2]
+
+    assert_equal 'red', v1st[:alternative]
+    assert_equal '0000-0000-0000-0000', v1st[:client_id]
+    assert_nil v1st[:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', v1st[:experiment]
+
+    assert_equal 'blue', v2nd[:alternative]
+    assert_equal '0000-0000-0000-0001', v2nd[:client_id]
+    assert_nil v2nd[:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', v2nd[:experiment]
+
+    assert_equal 'green', v3rd[:alternative]
+    assert_equal '0000-0000-0000-0002', v3rd[:client_id]
+    assert_nil v3rd[:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', v3rd[:experiment]
+  end
+
+  def test_threading
+    d = create_driver(CONFIG_THREADING_KEEPALIVE, 'test.metrics')
+    ['red', 'blue', 'green'].each_with_index do |color, i|
+      d.emit({'record_type' => 'participate',
+             'alternatives' => 'red,blue,green',
+             'alternative'  =>  color,
+             'client_id'  => "0000-0000-0000-000#{i}",
+             'experiment' => 'experiment_test_threading_non_keepalive'})
+      sleep 0.5 # wait internal posting thread loop
+    end
+
+    assert_equal 3, @posted.size
+    v1st = @posted[0]
+    v2nd = @posted[1]
+    v3rd = @posted[2]
+
+    assert_equal 'red', v1st[:alternative]
+    assert_equal '0000-0000-0000-0000', v1st[:client_id]
+    assert_nil v1st[:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', v1st[:experiment]
+
+    assert_equal 'blue', v2nd[:alternative]
+    assert_equal '0000-0000-0000-0001', v2nd[:client_id]
+    assert_nil v2nd[:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', v2nd[:experiment]
+
+    assert_equal 'green', v3rd[:alternative]
+    assert_equal '0000-0000-0000-0002', v3rd[:client_id]
+    assert_nil v3rd[:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', v3rd[:experiment]
+  end
+
+  def test_threading_non_keepalive
+    d = create_driver(CONFIG_THREADING_NON_KEEPALIVE, 'test.metrics')
+    ['red', 'blue', 'green'].each_with_index do |color, i|
+      d.emit({'record_type' => 'participate',
+             'alternatives' => 'red,blue,green',
+             'alternative'  =>  color,
+             'client_id'  => "0000-0000-0000-000#{i}",
+             'experiment' => 'experiment_test_threading_non_keepalive'})
+      d.run
+      sleep 0.5 # wait internal posting thread loop
+    end
+
+    assert_equal 3, @posted.size
+    v1st = @posted[0]
+    v2nd = @posted[1]
+    v3rd = @posted[2]
+
+    assert_equal 'red', v1st[:alternative]
+    assert_equal '0000-0000-0000-0000', v1st[:client_id]
+    assert_nil v1st[:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', v1st[:experiment]
+
+    assert_equal 'blue', v2nd[:alternative]
+    assert_equal '0000-0000-0000-0001', v2nd[:client_id]
+    assert_nil v2nd[:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', v2nd[:experiment]
+
+    assert_equal 'green', v3rd[:alternative]
+    assert_equal '0000-0000-0000-0002', v3rd[:client_id]
+    assert_nil v3rd[:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', v3rd[:experiment]
+  end
+
+
+  # setup / teardown for servers
+  def setup
+    Fluent::Test.setup
+    @posted = []
+    @prohibited = 0
+    @auth = false
+    @enable_float_number = false
+    @dummy_server_thread = Thread.new do
+      srv = if ENV['VERBOSE']
+              WEBrick::HTTPServer.new({:BindAddress => '127.0.0.1', :Port => SIXPACK_TEST_LISTEN_PORT})
+            else
+              logger = WEBrick::Log.new('/dev/null', WEBrick::BasicLog::DEBUG)
+              WEBrick::HTTPServer.new({:BindAddress => '127.0.0.1', :Port => SIXPACK_TEST_LISTEN_PORT, :Logger => logger, :AccessLog => []})
+            end
+      begin
+        srv.mount_proc('/participate') { |req,res|
+          unless req.request_method == 'GET'
+            res.status = 405
+            res.body = 'request method mismatch'
+            next
+          end
+          if @auth and req.header['authorization'][0] == 'Basic YWxpY2U6c2VjcmV0IQ==' # pattern of user='alice' passwd='secret!'
+            # ok, authorized
+          elsif @auth
+            res.status = 403
+            @prohibited += 1
+            next
+          else
+            # ok, authorization not required
+          end
+
+          @posted.push({
+              :alternatives=> req.query["alternatives"],
+              :alternative => req.query["alternative"],
+              :client_id   => req.query["client_id"],
+              :experiment  => req.query["experiment"]
+            })
+
+          res.status = 200
+        }
+        srv.mount_proc('/convert') { |req,res|
+          @posted.push({
+              :client_id   => req.query["client_id"],
+              :experiment  => req.query["experiment"]
+            })
+          res.status = 200
+        }
+        srv.mount_proc('/') { |req,res|
+          res.status = 200
+          res.body = 'running'
+        }
+        srv.start
+      ensure
+        srv.shutdown
+      end
+    end
+
+    # to wait completion of dummy server.start()
+    require 'thread'
+    cv = ConditionVariable.new
+    watcher = Thread.new {
+      connected = false
+      while not connected
+        begin
+          get_content('localhost', SIXPACK_TEST_LISTEN_PORT, '/')
+          connected = true
+        rescue Errno::ECONNREFUSED
+          sleep 0.1
+        rescue StandardError => e
+          p e
+          sleep 0.1
+        end
+      end
+      cv.signal
+    }
+    mutex = Mutex.new
+    mutex.synchronize {
+      cv.wait(mutex)
+    }
+  end
+
+  def test_dummy_server
+    d = create_driver
+    d.instance.sixpackapi_url =~ /^http:\/\/([.:a-z0-9]+)\//
+    server = $1
+    host = server.split(':')[0]
+    port = server.split(':')[1].to_i
+    client = Net::HTTP.start(host, port)
+
+    assert_equal '200', client.request_get('/').code
+    assert_equal '200', client.request_get('/participate?experiment=experiment_test_threading_non_keepalive&alternatives=red&alternatives=blue&alternatives=green&alternative=green&client_id=0000-0000-0000-0001').code
+
+    assert_equal 1, @posted.size
+
+    assert_equal 'green', @posted[0][:alternative]
+    assert_equal '0000-0000-0000-0001', @posted[0][:client_id]
+    assert_nil @posted[0][:auth]
+    assert_equal 'experiment_test_threading_non_keepalive', @posted[0][:experiment]
+
+    @auth = true
+
+    req_with_auth = lambda do |number, mode, user, pass|
+      url = URI.parse("http://#{host}:#{port}/participate")
+      req = Net::HTTP::Get.new(url.path)
+      req.basic_auth user, pass
+      req.set_form_data({'number'=>number, 'mode'=>mode})
+      req
+    end
+
+    assert_equal '403', client.request(req_with_auth.call(500, 'count', 'alice', 'wrong password!')).code
+
+    assert_equal 1, @posted.size
+
+    assert_equal '200', client.request(req_with_auth.call(500, 'count', 'alice', 'secret!')).code
+
+    assert_equal 2, @posted.size
+
+  end
+
+  def teardown
+    @dummy_server_thread.kill
+    @dummy_server_thread.join
+  end
+
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: fluent-plugin-sixpack
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Naoki AINOYA
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fluent-mixin-config-placeholders
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resolve-hostname
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+description: 'For sixpack, see http://sixpack.seatgeek.com '
+email:
+- ainonic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".document"
+- ".gitignore"
+- ".travis.yml"
+- AUTHORS
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- fluent-plugin-sixpack.gemspec
+- lib/fluent/plugin/out_sixpack.rb
+- test/helper.rb
+- test/plugin/test_out_growthforecast.rb
+homepage: https://github.com/ainoya/fluent-plugin-sixpack
+licenses:
+- APLv2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Fluentd output plugin to post numbers to sixpack (by seatgeek)
+test_files:
+- test/helper.rb
+- test/plugin/test_out_growthforecast.rb