logstash-output-influxdb 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d30a313b6e704668859f42ae9b5023624fbf35e
-  data.tar.gz: c5b7c44f82b8098a727713596cc1762dc92a0893
+  metadata.gz: 319717ea8b3dc90eec8c3bd3a894afc74481301d
+  data.tar.gz: f6e7ec77f79060860a7bd4ff65b922cd6c678418
 SHA512:
-  metadata.gz: a22503dc7cecf37e1f71ca21aa2aa8404f5547756b326b25b529eb45f335056b3eb4ce3a426e00a13be4fc11c4ab1be28ee1474fb547e48b8babae15e2b926eb
-  data.tar.gz: 73f9fa98aa9e32f7d9f9facd88dd221e87b5e7518607b66ebc890e587387f24ee0efc05e0b907b702807085e59ff79ccd721ecb6770719be767b3f4bf71f1562
+  metadata.gz: 0c57304545fe95980fdfa2b1cce14802875ef2ddbb969c12399cddcea7dea82df0bdaffada54b3e2f15b6c09914236d834a873360b2d7c7eb7277a4b104c45f4
+  data.tar.gz: a0a8308b93ac08067a67910251be2e8abbc6cb54b2c256bc25c9237de4e4afe4f0285e5fa59960e7b05d93c93df50df92ae5bfa7c703c3cb5a7eaeaffd12aadf

data/CHANGELOG.md

@@ -1,14 +1,18 @@
+## 5.0.0 
+ - Use the official influxdb client. This doesn't change the config options, but has some
+   breakage potential, so this is a major version bump.
+
 ## 4.0.0
-   - Breaking: Updated plugin to use new Java Event APIs
-   - Fix the suite related to the new java event and the ordering of the keys in the hash.
-   - Relax logstash-core-plugin-api constraints
-   - update .travis.yml
+ - Breaking: Updated plugin to use new Java Event APIs
+ - Fix the suite related to the new java event and the ordering of the keys in the hash.
+ - Relax logstash-core-plugin-api constraints
+ - update .travis.yml
 
 ## 3.1.2
-  - Depend on logstash-core-plugin-api instead of logstash-core, removing the need to mass update plugins on major releases of logstash
+ - Depend on logstash-core-plugin-api instead of logstash-core, removing the need to mass update plugins on major releases of logstash
 
 ## 3.1.1
-  - New dependency requirements for logstash-core for the 5.0 release
+ - New dependency requirements for logstash-core for the 5.0 release
 
 ## 3.1.0
  - New option to enable SSL/TLS encrypted communication to InfluxDB

data/lib/logstash/outputs/influxdb.rb

@@ -3,6 +3,7 @@ require "logstash/namespace"
 require "logstash/outputs/base"
 require "logstash/json"
 require "stud/buffer"
+require "influxdb"
 
 # This output lets you output Metrics to InfluxDB (>= 0.9.0-rc31)
 #
@@ -23,7 +24,7 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
   config :db, :validate => :string, :default => "statistics"
 
   # The retention policy to use
-  config :retention_policy, :validate => :string, :default => "default"
+  config :retention_policy, :validate => :string, :default => "autogen"
 
   # The hostname or IP address to reach your InfluxDB instance
   config :host, :validate => :string, :required => true
@@ -107,22 +108,35 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
   # This helps keep both fast and slow log streams moving along in
   # near-real-time.
   config :idle_flush_time, :validate => :number, :default => 1
-
+  
+  # The amount of time in seconds to delay the initial retry on connection failure.  
+  #
+  # The delay will increase exponentially for each retry attempt (up to max_retries).
+  
+  config :initial_delay, :validate => :number, :default => 1
+  
+  # The number of time to retry recoverable errors before dropping the events.
+  #
+  # A value of -1 will cause the plugin to retry indefinately.
+  # A value of 0 will cause the plugin to never retry.
+  # Otherwise it will retry up to the specified mumber of times.
+  #
+  config :max_retries, :validate => :number, :default => 3
 
   public
   def register
-    require 'manticore'
     require 'cgi'
     
-    @client = Manticore::Client.new
     @queue = []
-    @protocol = @ssl ? "https" : "http"
 
     buffer_initialize(
       :max_items => @flush_size,
       :max_interval => @idle_flush_time,
       :logger => @logger
     )
+    @auth_method = @user.nil? ? 'none'.freeze  : "params".freeze 
+    
+    @influxdbClient = InfluxDB::Client.new host: @host, port: @port, time_precision: @time_precision, use_ssl: @ssl, verify_ssl: false, retry: @max_retries, initial_delay: @initial_delay, auth_method: @auth_method, username: @user, password: @password.value
   end # def register
 
 
@@ -154,11 +168,11 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
     tags, point = extract_tags(point)
 
     event_hash = {
-      "measurement" => event.sprintf(@measurement),
-      "time"        => time,
-      "fields"      => point
+      :series => event.sprintf(@measurement),
+      :timestamp       => time,
+      :values      => point
     }
-    event_hash["tags"] = tags unless tags.empty?
+    event_hash[:tags] = tags unless tags.empty?
 
     buffer_receive(event_hash, event.sprintf(@db))
   end # def receive
@@ -166,67 +180,26 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
 
   def flush(events, database, teardown = false)
     @logger.debug? and @logger.debug("Flushing #{events.size} events to #{database} - Teardown? #{teardown}")
-    post(events_to_request_body(events), database)
+    dowrite(events, database)
   end # def flush
-
-
-  def post(body, database, proto = @protocol)
+    
+  def dowrite(events, database)
     begin
-      @query_params = "db=#{database}&rp=#{@retention_policy}&precision=#{@time_precision}&u=#{@user}&p=#{@password.value}"
-      @base_url = "#{proto}://#{@host}:#{@port}/write"
-      @url = "#{@base_url}?#{@query_params}"
-
-      @logger.debug? and @logger.debug("POSTing to #{@url}")
-      @logger.debug? and @logger.debug("Post body: #{body}")
-      response = @client.post!(@url, :body => body)
-  
-    rescue EOFError
-      @logger.warn("EOF while writing request or reading response header from InfluxDB",
-                   :host => @host, :port => @port)
-      return # abort this flush
+        @influxdbClient.write_points(events, @time_precision, @retention_policy, @db  )
+    rescue InfluxDB::AuthenticationError => ae
+        @logger.warn("Authentication Error while writing to InfluxDB", :exception => ae)
+    rescue InfluxDB::ConnectionError => ce 
+        @logger.warn("Connection Error while writing to InfluxDB", :exception => ce)
+    rescue Exception => e
+        @logger.warn("Non recoverable exception while writing to InfluxDB", :exception => ce)
     end
-
-    if read_body?(response)
-      # Consume the body for error checking
-      # This will also free up the connection for reuse.
-      body = ""
-      begin
-        response.read_body { |chunk| body += chunk }
-      rescue EOFError
-        @logger.warn("EOF while reading response body from InfluxDB",
-                     :host => @host, :port => @port)
-        return # abort this flush
-      end
-
-      @logger.debug? and @logger.debug("Body: #{body}")
-    end
-
-    unless response && (200..299).include?(response.code)
-      @logger.error("Error writing to InfluxDB",
-                    :response => response, :response_body => body,
-                    :request_body => @queue.join("\n"))
-      return
-    else
-      @logger.debug? and @logger.debug("Post response: #{response}")
-    end
-  end # def post
+  end
 
   def close
     buffer_flush(:final => true)
   end # def teardown
 
-
-  # A batch POST for InfluxDB 0.9 looks like this:
-  # cpu_load_short,host=server01,region=us-west value=0.64 cpu_load_short,host=server02,region=us-west value=0.55 1422568543702900257 cpu_load_short,direction=in,host=server01,region=us-west value=23422.0 1422568543702900257  
-  def events_to_request_body(events)
-    events.map do |event|
-      result = escaped_measurement(event["measurement"].dup)
-      result << "," << event["tags"].map { |tag,value| "#{escaped(tag)}=#{escaped(value)}" }.join(',') if event.has_key?("tags")
-      result << " " << event["fields"].map { |field,value| "#{escaped(field)}=#{quoted(value)}" }.join(',')
-      result << " #{event["time"]}"
-    end.join("\n") #each measurement should be on a separate line
-  end
-
+ 
   # Create a data point from an event. If @use_event_fields_for_data_points is
   # true, convert the event to a hash. Otherwise, use @data_points. Each key and 
   # value will be run through event#sprintf with the exception of a non-String
@@ -327,30 +300,4 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
     (timestamp.to_f * multiplier).to_i
   end
 
-
-  # Only read the response body if its status is not 1xx, 204, or 304. TODO: Should 
-  # also not try reading the body if the request was a HEAD
-  def read_body?( response )
-    ! (response.nil? || [204,304].include?(response.code) || (100..199).include?(response.code))
-  end
-
-
-  # Return a quoted string of the given value if it's not a number
-  def quoted(value)
-    Numeric === value ? value : %Q|"#{value.gsub('"','\"')}"|
-  end
-
-
-  # Escape tag key, tag value, or field key
-  def escaped(value)
-    value.gsub(/[ ,=]/, ' ' => '\ ', ',' => '\,', '=' => '\=')
-  end
-
-
-  # Escape measurements note they don't need to worry about the '=' case
-  def escaped_measurement(value)
-    value.gsub(/[ ,]/, ' ' => '\ ', ',' => '\,')
-  end
-
-
 end # class LogStash::Outputs::InfluxDB

data/logstash-output-influxdb.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name            = 'logstash-output-influxdb'
-  s.version         = '4.0.0'
+  s.version         = '5.0.0'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "This output lets you output Metrics to InfluxDB"
   s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program"
@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "logstash-core-plugin-api", ">= 1.60", "<= 2.99"
 
   s.add_runtime_dependency 'stud'
-  s.add_runtime_dependency 'manticore'
+  s.add_runtime_dependency 'influxdb' , ">= 0.3", "<= 0.3.99"
 
   s.add_development_dependency 'logstash-devutils'
   s.add_development_dependency 'logstash-input-generator'

data/spec/outputs/influxdb_spec.rb

@@ -1,34 +1,98 @@
 # encoding: utf-8
 require "logstash/devutils/rspec/spec_helper"
 require "logstash/outputs/influxdb"
-require "manticore"
 
 describe LogStash::Outputs::InfluxDB do
 
-  let(:pipeline) { LogStash::Pipeline.new(config) }
+  subject { LogStash::Outputs::InfluxDB.new(config) }
+    
+  context "validate minimal default config" do
 
+    let(:config) do
+    {
+      "host" => "testhost",
+      "use_event_fields_for_data_points" => true
+    }
+    end
+
+    before do
+      subject.register
+      subject.close
+    end
+
+    it "sets correct influx client settings" do
+
+      config = subject.instance_variable_get(:@influxdbClient).config
+
+      expect(config.next_host).to eq "testhost"  
+      expect(config.instance_variable_get(:@port)).to eq 8086 
+      expect(config.instance_variable_get(:@time_precision)).to eq "ms" 
+      expect(config.instance_variable_get(:@auth_method)).to eq "none".freeze 
+      expect(config.instance_variable_get(:@initial_delay)).to eq 1
+      expect(config.instance_variable_get(:@retry)).to eq 3
+      expect(config.instance_variable_get(:@use_ssl)).to eq false
+      expect(config.instance_variable_get(:@username)).to eq nil 
+      expect(config.instance_variable_get(:@password)).to eq nil 
+
+    end
+
+  end
+
+  context "validate non default config" do
+
+    let(:config) do
+    {
+      "host" => "localhost",
+      "use_event_fields_for_data_points" => true,
+      "port" => 9999,
+      "ssl" => true,
+      "user" => "my_user",
+      "password" => "my_pass",
+      "initial_delay" => 5,
+      "max_retries" => 8,
+      "time_precision" => "s"
+    }
+    end
+
+    before do
+      subject.register
+      subject.close
+    end
+
+    it "sets correct influx client settings" do
+      config = subject.instance_variable_get(:@influxdbClient).config
+      expect(config.instance_variable_get(:@port)).to eq 9999
+      expect(config.instance_variable_get(:@time_precision)).to eq "s"   
+      expect(config.instance_variable_get(:@initial_delay)).to eq 5
+      expect(config.instance_variable_get(:@retry)).to eq 8
+      expect(config.instance_variable_get(:@use_ssl)).to eq true    
+      expect(config.instance_variable_get(:@username)).to eq "my_user"
+      expect(config.instance_variable_get(:@password)).to eq "my_pass"  
+      expect(config.instance_variable_get(:@auth_method)).to eq "params".freeze           
+    end
+
+  end
+  
   context "complete pipeline run with 2 events" do
 
     let(:config) do
-      {
-        "host" => "localhost",
-        "user" => "someuser",
-        "password" => "somepwd",
-        "allow_time_override" => true,
-        "data_points" => {
-          "foo" => "%{foo}",
-          "bar" => "%{bar}",
-          "time" => "%{time}"
-        }
+    {
+      "host" => "localhost",
+      "user" => "someuser",
+      "password" => "somepwd",
+      "allow_time_override" => true,
+      "data_points" => {
+        "foo" => "%{foo}",
+        "bar" => "%{bar}",
+        "time" => "%{time}"
       }
+    }
     end
 
-    subject { LogStash::Outputs::InfluxDB.new(config) }
-
     before do
       subject.register
       # Added db name parameter to post - M.Laws
-      allow(subject).to receive(:post).with(result, "statistics")
+      allow(subject).to receive(:dowrite).with(result, "statistics")
 
       2.times do
         subject.receive(LogStash::Event.new("foo" => "1", "bar" => "2", "time" => "3", "type" => "generator"))
@@ -38,365 +102,138 @@ describe LogStash::Outputs::InfluxDB do
       subject.close
     end
 
-    let(:result) { "logstash foo=\"1\",bar=\"2\" 3\nlogstash foo=\"1\",bar=\"2\" 3" }
+    #let(:result) { "logstash foo=\"1\",bar=\"2\" 3\nlogstash foo=\"1\",bar=\"2\" 3" }
+
+    let(:result) {[{:series=>"logstash", :timestamp=>"3", :values=>{"foo"=>"1", "bar"=>"2"}}, {:series=>"logstash", :timestamp=>"3", :values=>{"foo"=>"1", "bar"=>"2"}}]}
 
     it "should receive 2 events, flush and call post with 2 items json array" do
-      expect(subject).to have_received(:post).with(result, "statistics")
+      expect(subject).to have_received(:dowrite).with(result, "statistics")
     end
 
   end
 
   context "using event fields as data points" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             message => "foo=1 bar=2 time=3"
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv { }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             measurement => "my_series"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => ["@version", "@timestamp", "sequence", "message", "type", "host"]
-           }
-         }
-      CONFIG
+
+    let(:config) do
+    {
+      "host" => "localhost",
+      "measurement" => "my_series",
+      "allow_time_override" => true,
+      "use_event_fields_for_data_points" => true
+    }
     end
 
-    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
-    let(:expected_body) { 'my_series bar="2",foo="1" 3' }
+    before do
+      subject.register
+      # Added db name parameter to post - M.Laws
+      allow(subject).to receive(:dowrite).with(result, "statistics")
 
-    it "should use the event fields as the data points, excluding @version and @timestamp by default as well as any fields configured by exclude_fields" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
-    end
-  end
+      subject.receive(LogStash::Event.new("foo" => "1", "bar" => "2", "time" => "3", "type" => "generator"))
 
-  context "sending some fields as Influxdb tags" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             message => "foo=1 bar=2 baz=3 time=4"
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv { }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             measurement => "my_series"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => ["@version", "@timestamp", "sequence", "message", "type", "host"]
-             send_as_tags => ["bar", "baz", "qux"]
-           }
-         }
-      CONFIG
+      # Close / flush the buffer
+      subject.close
     end
 
-    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
-    let(:expected_body) { 'my_series,bar=2,baz=3 foo="1" 4' }
+    let(:result) {[{:series=>"my_series", :timestamp=>"3", :values=>{"foo"=>"1", "bar"=>"2"}}]}
 
-    it "should send the specified fields as tags" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
+    it "should use the event fields as the data points, excluding @version and @timestamp by default as well as any fields configured by exclude_fields" do
+      expect(subject).to have_received(:dowrite).with(result, "statistics")
     end
-  end
 
-  context "Escapeing space characters" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             message => "foo=1 bar=2 baz=3 time=4"
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv { 
-	      add_field => {
-		"test1" => "yellow cat"
-		"test space" => "making life hard"
-		"feild space" => "pink dog"
-	      }
-	   }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             measurement => "my series"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => ["@version", "@timestamp", "sequence", "message", "type", "host"]
-             send_as_tags => ["bar", "baz", "test1", "test space"]
-           }
-         }
-      CONFIG
-    end
+  end
 
-    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
-    let(:expected_body) { 'my\ series,bar=2,baz=3,test1=yellow\ cat,test\ space=making\ life\ hard foo="1",feild\ space="pink dog" 4' }
 
-    it "should send the specified fields as tags" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
-    end
-  end
+  context "sending some fields as Influxdb tags" do
 
-  context "Escapeing comma characters" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             message => "foo=1 bar=2 baz=3 time=4"
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv {
-              add_field => {
-                "test1" => "yellow, cat"
-                "test, space" => "making, life, hard"
-                "feild, space" => "pink, dog"
-              }
-           }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             measurement => "my, series"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => ["@version", "@timestamp", "sequence", "message", "type", "host"]
-             send_as_tags => ["bar", "baz", "test1", "test, space"]
-           }
-         }
-      CONFIG
+    let(:config) do
+    {
+      "host" => "localhost",
+      "measurement" => "my_series",
+      "allow_time_override" => true,
+      "use_event_fields_for_data_points" => true,
+      "send_as_tags" => ["bar", "baz", "qux"]
+    }
     end
 
-    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
-    let(:expected_body) { 'my\,\ series,bar=2,baz=3,test1=yellow\,\ cat,test\,\ space=making\,\ life\,\ hard foo="1",feild\,\ space="pink, dog" 4' }
+    before do
+      subject.register
+      # Added db name parameter to post - M.Laws
+      allow(subject).to receive(:dowrite).with(result, "statistics")
 
-    it "should send the specified fields as tags" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
-    end
-  end
+      subject.receive(LogStash::Event.new("foo" => "1", "bar" => "2", "baz" => "3", "time" => "4", "type" => "generator"))
 
-  context "Escapeing equal characters" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             message => "foo=1 bar=2 baz=3 time=4"
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv {
-              add_field => {
-                "test1" => "yellow=cat"
-                "test=space" => "making= life=hard"
-                "feild= space" => "pink= dog"
-              }
-           }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             measurement => "my=series"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => ["@version", "@timestamp", "sequence", "message", "type", "host"]
-             send_as_tags => ["bar", "baz", "test1", "test=space"]
-           }
-         }
-      CONFIG
+      # Close / flush the buffer
+      subject.close
     end
 
-    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
-    let(:expected_body) { 'my=series,bar=2,baz=3,test1=yellow\=cat,test\=space=making\=\ life\=hard foo="1",feild\=\ space="pink= dog" 4' }
+    let(:result) {[{:series=>"my_series", :timestamp=>"4", :tags=>{"bar"=>"2", "baz"=>"3"}, :values=>{"foo"=>"1"}}]}
 
-    it "should send the specified fields as tags" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
+    it "should use the event fields as the data points, excluding @version and @timestamp by default as well as any fields configured by exclude_fields" do
+      expect(subject).to have_received(:dowrite).with(result, "statistics")
     end
-  end
 
-  context "testing backslash characters" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             message => 'foo\\=1 bar=2 baz=3 time=4'
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv {
-              add_field => {
-                "test1" => "yellow=cat"
-                "test=space" => "making=, life=hard"
-                "feildspace" => 'C:\\Griffo'
-              }
-           }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             measurement => 'my\\series'
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => ["@version", "@timestamp", "sequence", "message", "type", "host"]
-             send_as_tags => ['bar', "baz", "test1", "test=space"]
-           }
-         }
-      CONFIG
-    end
+  end
 
-    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
-    let(:expected_body) { 'my\series,bar=2,baz=3,test1=yellow\=cat,test\=space=making\=\,\ life\=hard foo\="1",feildspace="C:\Griffo" 4' }
+  context "when fields data contains a list of tags" do
 
-    it "should send the specified fields as tags" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
+    let(:config) do
+    {
+      "host" => "localhost",
+      "measurement" => "my_series",
+      "allow_time_override" => true,
+      "use_event_fields_for_data_points" => true,
+    }
     end
-  end
 
+    before do
+      subject.register
+      # Added db name parameter to post - M.Laws
+      allow(subject).to receive(:dowrite).with(result, "statistics")
+
+      subject.receive(event)
 
-  context "when fields data contains a list of tags" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             message => "foo=1 time=2"
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv { add_tag => [ "tagged" ] }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             measurement => "my_series"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => ["@version", "@timestamp", "sequence", "message", "type", "host"]
-           }
-         }
-      CONFIG
+      # Close / flush the buffer
+      subject.close
     end
+    
+    let(:event) {LogStash::Event.new("foo" => "1", "time" => "2", "tags" => ["tagged"], "type" => "generator")}
+    let(:result) {[{:series=>"my_series", :timestamp=>"2", :tags=>{"tagged"=>"true"}, :values=>{"foo"=>"1"}}]}
 
-    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
-    let(:expected_body) { 'my_series,tagged=true foo="1" 2' }
-
-    it "should move them to the tags data" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
+    it "should use the event fields as the data points, excluding @version and @timestamp by default as well as any fields configured by exclude_fields" do
+      expect(subject).to have_received(:dowrite).with(result, "statistics")
     end
+
   end
 
   context "when fields are coerced to numerics" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             message => "foo=1 bar=2 baz=\\\"quotes\\\" time=3"
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv { }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             measurement => "my_series"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => ["@version", "@timestamp", "sequence", "message", "type", "host"]
-             coerce_values => { "foo" => "integer" "bar" => "float" }
-           }
-         }
-      CONFIG
+
+    let(:config) do
+    {
+      "host" => "localhost",
+      "measurement" => "my_series",
+      "allow_time_override" => true,
+      "use_event_fields_for_data_points" => true,
+      "coerce_values" => { "foo" => "integer", "bar" => "float" }
+    }
     end
 
-    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
-    let(:expected_body) { 'my_series bar=2.0,foo=1,baz="\\\"quotes\\\"" 3' } # We want the backslash and the escaped-quote in the request body
+    before do
+      subject.register
+      # Added db name parameter to post - M.Laws
+      allow(subject).to receive(:dowrite).with(result, "statistics")
 
-    it "should quote all other values (and escaping double quotes)" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
-    end
-  end
+      subject.receive(LogStash::Event.new("foo" => "1", "bar" => "2.0", "baz"=>"\\\"quotes\\\"", "time"=>3, "type" => "generator"))
 
-  # Test issue #32 - Add support for HTTPS via configuration
-  # --------------------------------------------------------
-  # A simple test to verify that setting the ssl configuration option works
-  # similar to other Logstash output plugins (specifically the Elasticsearch
-  # output plugin). 
-  context "setting the ssl configuration option to true" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             message => "foo=1 bar=2 baz=3 time=4"
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv { }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             ssl => true
-             measurement => "barfoo"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => [ "@version", "@timestamp", "sequence",
-                                 "message", "type", "host" ]
-           }
-         }
-      CONFIG
+      # Close / flush the buffer
+    subject.close
     end
 
-    let(:expected_url)  { 'https://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p=' }
-    let(:expected_body) { 'barfoo bar="2",foo="1",baz="3" 4' }
+    let(:result) {[{:series=>"my_series", :timestamp=>3, :values=>{"foo"=>1, "bar"=>2.0, "baz"=>"\\\"quotes\\\"" }}]}
 
-    it "should POST to an https URL" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
+    it "should use the event fields as the data points, excluding @version and @timestamp by default as well as any fields configured by exclude_fields" do
+      expect(subject).to have_received(:dowrite).with(result, "statistics")
     end
+
   end
 
   # Test issue #31 - Run "db" parameter through event.sprintf() to support...
@@ -405,49 +242,35 @@ describe LogStash::Outputs::InfluxDB do
   # DATABASE continue to work *after* implementing #31.  Also verifies that
   # sprintf formatting is supported in the measurement name.
   context "receiving 3 points between 2 measurements in 1 database" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             lines => [
-               "foo=1 bar=2 baz=m1 time=1",
-               "foo=3 bar=4 baz=m2 time=2",
-               "foo=5 bar=6 baz=m2 time=3"
-             ]
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv { }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             db => "barfoo"
-             measurement => "%{baz}"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => [ "@version", "@timestamp", "sequence",
-                                 "message", "type", "host" ]
-           }
-         }
-      CONFIG
+
+    let(:config) do
+    {
+      "host" => "localhost",
+      "measurement" => "%{baz}",
+      "allow_time_override" => true,
+      "use_event_fields_for_data_points" => true
+    }
     end
 
-    let(:expected_url)  { 'http://localhost:8086/write?db=barfoo&rp=default&precision=ms&u=&p=' }
-    let(:expected_body) { "m1 bar=\"2\",foo=\"1\",baz=\"m1\" 1\nm2 bar=\"4\",foo=\"3\",baz=\"m2\" 2\nm2 bar=\"6\",foo=\"5\",baz=\"m2\" 3" }
+    before do
+      subject.register
+      # Added db name parameter to post - M.Laws
+      allow(subject).to receive(:dowrite)
+
+      subject.receive(LogStash::Event.new("foo"=>"1", "bar"=>"2", "baz" => "m1", "time" => "1", "type" => "generator"))
+      subject.receive(LogStash::Event.new("foo"=>"3", "bar"=>"4", "baz" => "m2", "time" => "2", "type" => "generator"))
+      subject.receive(LogStash::Event.new("foo"=>"5", "bar"=>"6", "baz" => "m2", "time" => "3", "type" => "generator"))
 
-    it "should result in a single POST (one per database)" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).once
-      pipeline.run
+      # Close / flush the buffer
+      subject.close
     end
 
-    it "should POST in bulk format" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url, body: expected_body)
-      pipeline.run
+    let(:result) {[{:series=>"m1", :timestamp=>"1", :values=>{"foo"=>"1", "bar"=>"2", "baz" => "m1" }},{:series=>"m2", :timestamp=>"2", :values=>{"foo"=>"3", "bar"=>"4", "baz" => "m2"}},{:series=>"m2", :timestamp=>"3", :values=>{"foo"=>"5", "bar"=>"6", "baz" => "m2" }}]}
+
+    it "should use the event fields as the data points, excluding @version and @timestamp by default as well as any fields configured by exclude_fields" do
+      expect(subject).to have_received(:dowrite).with(result, "statistics")
     end
+
   end
 
   # Test issue #31 - Run "db" parameter through event.sprintf() to support...
@@ -458,52 +281,38 @@ describe LogStash::Outputs::InfluxDB do
   # Also verifies that sprintf formatting is correctly supported in the
   # database name.
   context "receiving 4 points between 2 measurements in 2 databases" do
-    let(:config) do <<-CONFIG
-        input {
-           generator {
-             lines => [
-               "foo=1 bar=db1 baz=m1 time=1",
-               "foo=2 bar=db1 baz=m2 time=2",
-               "foo=3 bar=db2 baz=m1 time=3",
-               "foo=4 bar=db2 baz=m2 time=4"
-             ]
-             count => 1
-             type => "generator"
-           }
-         }
-
-         filter {
-           kv { }
-         }
-
-         output {
-           influxdb {
-             host => "localhost"
-             db => "%{bar}"
-             measurement => "%{baz}"
-             allow_time_override => true
-             use_event_fields_for_data_points => true
-             exclude_fields => [ "@version", "@timestamp", "sequence",
-                                 "message", "type", "host" ]
-           }
-         }
-      CONFIG
+
+    let(:config) do
+    {
+      "host" => "localhost",
+      "db" => "%{bar}",
+      "measurement" => "%{baz}",
+      "allow_time_override" => true,
+      "use_event_fields_for_data_points" => true,
+    }
     end
 
-    let(:expected_url_db1)  { 'http://localhost:8086/write?db=db1&rp=default&precision=ms&u=&p=' }
-    let(:expected_url_db2)  { 'http://localhost:8086/write?db=db2&rp=default&precision=ms&u=&p=' }
-    let(:expected_body_db1) { "m1 bar=\"db1\",foo=\"1\",baz=\"m1\" 1\nm2 bar=\"db1\",foo=\"2\",baz=\"m2\" 2" }
-    let(:expected_body_db2) { "m1 bar=\"db2\",foo=\"3\",baz=\"m1\" 3\nm2 bar=\"db2\",foo=\"4\",baz=\"m2\" 4" }
+    before do
+      subject.register
+      # Added db name parameter to post - M.Laws
+      allow(subject).to receive(:dowrite)
 
-    it "should result in two POSTs (one per database)" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).twice
-      pipeline.run
+      subject.receive(LogStash::Event.new("foo"=>"1", "bar"=>"db1", "baz" => "m1", "time" => "1", "type" => "generator"))
+      subject.receive(LogStash::Event.new("foo"=>"2", "bar"=>"db1", "baz" => "m1", "time" => "2", "type" => "generator"))
+      subject.receive(LogStash::Event.new("foo"=>"3", "bar"=>"db2", "baz" => "m2", "time" => "3", "type" => "generator"))
+      subject.receive(LogStash::Event.new("foo"=>"4", "bar"=>"db2", "baz" => "m2", "time" => "4", "type" => "generator"))
+      # Close / flush the buffer
+      subject.close
     end
 
-    it "should post in bulk format" do
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url_db1, body: expected_body_db1)
-      expect_any_instance_of(Manticore::Client).to receive(:post!).with(expected_url_db2, body: expected_body_db2)
-      pipeline.run
+    let(:resultdb1) {[{:series=>"m1", :timestamp=>"1", :values=>{"foo"=>"1", "bar"=>"db1", "baz" => "m1" }},{:series=>"m1", :timestamp=>"2", :values=>{"foo"=>"2", "bar"=>"db1", "baz" => "m1" }}]}
+    let(:resultdb2) {[{:series=>"m2", :timestamp=>"3", :values=>{"foo"=>"3", "bar"=>"db2", "baz" => "m2" }},{:series=>"m2", :timestamp=>"4", :values=>{"foo"=>"4", "bar"=>"db2", "baz" => "m2" }}]}
+
+    it "should use the event fields as the data points, excluding @version and @timestamp by default as well as any fields configured by exclude_fields" do
+      expect(subject).to have_received(:dowrite).with(resultdb1, "db1").once
+      expect(subject).to have_received(:dowrite).with(resultdb2, "db2").once
     end
+
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-influxdb
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-09-09 00:00:00.000000000 Z
+date: 2017-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -49,15 +49,21 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  name: manticore
+        version: '0.3'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.3.99
+  name: influxdb
   prerelease: false
   type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.3'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.3.99
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements: