logstash-output-influxdb 2.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c79dca49ee87b2359d0f3e2b88801cbfbf55e10
-  data.tar.gz: ae1dee54d2c300bb765d737cf9fcec6fbe14c422
+  metadata.gz: dc53920ba345ebe5e4e289819a5dfac55406720d
+  data.tar.gz: deb992fd046dbe441ba216971b96037169f45ef8
 SHA512:
-  metadata.gz: 6419b39ea5ef1c5910448b849e10256f5883f4046684b239d3864853dd57abcce59f18e81ced84750e60f4fe6c9e813a1706e8d03832b10c871b1970cec17cc0
-  data.tar.gz: 61242367818256debd322e8cb11a60e9d1706ba80d860060d126f5c1176a6391c3c224c19e62749754268243fe9b7f0e85cc087cb564b3994d354f5b2efb782c
+  metadata.gz: 96f4b4d2aff815c0df8cfba3f73030ff7fcf2402c16ec4123b5f844964b2cfa4049c0f34bc42d4ca60c81bd3b1278ac1e9c12cbf6b19ff6f4f256f97f2812606
+  data.tar.gz: ca510bc40ac465550485e9fbb128e9adfdaf86b2e78abba05844ef5745634f753bd7398bfbc2287c2fe3cb0b319cc02d882c9cb97eb8c8b4d0b8e7769473e972

data/README.md

@@ -1,5 +1,8 @@
 # Logstash Plugin
 
+[![Build
+Status](http://build-eu-00.elastic.co/view/LS%20Plugins/view/LS%20Outputs/job/logstash-plugin-output-influxdb-unit/badge/icon)](http://build-eu-00.elastic.co/view/LS%20Plugins/view/LS%20Outputs/job/logstash-plugin-output-influxdb-unit/)
+
 This is a plugin for [Logstash](https://github.com/elastic/logstash).
 
 It is fully free and fully open source. The license is Apache 2.0, meaning you are pretty much free to use it however you want in whatever way.

data/lib/logstash/outputs/influxdb.rb

@@ -4,11 +4,11 @@ require "logstash/outputs/base"
 require "logstash/json"
 require "stud/buffer"
 
-# This output lets you output Metrics to InfluxDB
+# This output lets you output Metrics to InfluxDB (>= 0.9.0-rc31)
 #
 # The configuration here attempts to be as friendly as possible
 # and minimize the need for multiple definitions to write to
-# multiple series and still be efficient
+# multiple measurements and still be efficient
 #
 # the InfluxDB API let's you do some semblance of bulk operation
 # per http call but each call is database-specific
@@ -20,7 +20,10 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
   config_name "influxdb"
 
   # The database to write
-  config :db, :validate => :string, :default => "stats"
+  config :db, :validate => :string, :default => "statistics"
+
+  # The retention policy to use
+  config :retention_policy, :validate => :string, :default => "default"
 
   # The hostname or IP address to reach your InfluxDB instance
   config :host, :validate => :string, :required => true
@@ -29,18 +32,18 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
   config :port, :validate => :number, :default => 8086
 
   # The user who has access to the named database
-  config :user, :validate => :string, :default => nil, :required => true
+  config :user, :validate => :string, :default => nil
 
   # The password for the user who access to the named database
-  config :password, :validate => :password, :default => nil, :required => true
+  config :password, :validate => :password, :default => nil
 
-  # Series name - supports sprintf formatting
-  config :series, :validate => :string, :default => "logstash"
+  # Measurement name - supports sprintf formatting
+  config :measurement, :validate => :string, :default => "logstash"
 
   # Hash of key/value pairs representing data points to send to the named database
   # Example: `{'column1' => 'value1', 'column2' => 'value2'}`
   #
-  # Events for the same series will be batched together where possible
+  # Events for the same measurement will be batched together where possible
   # Both keys and values support sprintf formatting
   config :data_points, :validate => :hash, :default => {}, :required => true
 
@@ -57,7 +60,7 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
   # Set the level of precision of `time`
   #
   # only useful when overriding the time value
-  config :time_precision, :validate => ["m", "s", "u"], :default => "s"
+  config :time_precision, :validate => ["n", "u", "ms", "s", "m", "h"], :default => "ms"
 
   # Allow value coercion
   #
@@ -69,8 +72,26 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
   #
   config :coerce_values, :validate => :hash, :default => {}
 
+  # Automatically use fields from the event as the data points sent to Influxdb
+  config :use_event_fields_for_data_points, :validate => :boolean, :default => false
+  
+  # An array containing the names of fields from the event to exclude from the
+  # data points 
+  # 
+  # Events, in general, contain keys "@version" and "@timestamp". Other plugins
+  # may add others that you'll want to exclude (such as "command" from the 
+  # exec plugin).
+  # 
+  # This only applies when use_event_fields_for_data_points is true.
+  config :exclude_fields, :validate => :array, :default => ["@timestamp", "@version", "sequence", "message", "type"]  
+
+  # An array containing the names of fields to send to Influxdb as tags instead 
+  # of fields. Influxdb 0.9 convention is that values that do not change every
+  # request should be considered metadata and given as tags.
+  config :send_as_tags, :validate => :array, :default => ["host"]
+
   # This setting controls how many events will be buffered before sending a batch
-  # of events. Note that these are only batched for the same series
+  # of events. Note that these are only batched for the same measurement
   config :flush_size, :validate => :number, :default => 100
 
   # The amount of time since last flush before a flush is forced.
@@ -84,15 +105,17 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
   # near-real-time.
   config :idle_flush_time, :validate => :number, :default => 1
 
+
   public
   def register
-    require "ftw" # gem ftw
+    require 'manticore'
     require 'cgi'
-    @agent = FTW::Agent.new
+    
+    @client = Manticore::Client.new
     @queue = []
 
-    @query_params = "u=#{@user}&p=#{@password.value}&time_precision=#{@time_precision}"
-    @base_url = "http://#{@host}:#{@port}/db/#{@db}/series"
+    @query_params = "db=#{@db}&rp=#{@retention_policy}&precision=#{@time_precision}&u=#{@user}&p=#{@password.value}"
+    @base_url = "http://#{@host}:#{@port}/write"
     @url = "#{@base_url}?#{@query_params}"
 
     buffer_initialize(
@@ -102,128 +125,229 @@ class LogStash::Outputs::InfluxDB < LogStash::Outputs::Base
     )
   end # def register
 
+
   public
   def receive(event)
     
 
-    # A batch POST for InfluxDB looks like this:
-    # [
-    #   {
-    #     "name": "events",
-    #     "columns": ["state", "email", "type"],
-    #     "points": [
-    #       ["ny", "paul@influxdb.org", "follow"],
-    #       ["ny", "todd@influxdb.org", "open"]
-    #     ]
-    #   },
-    #   {
-    #     "name": "errors",
-    #     "columns": ["class", "file", "user", "severity"],
-    #     "points": [
-    #       ["DivideByZero", "example.py", "someguy@influxdb.org", "fatal"]
-    #     ]
-    #   }
-    # ]
-    event_hash = {}
-    event_hash['name'] = event.sprintf(@series)
-
-    sprintf_points = Hash[@data_points.map {|k,v| [event.sprintf(k), event.sprintf(v)]}]
-    if sprintf_points.has_key?('time')
+    @logger.debug? and @logger.debug("Influxdb output: Received event: #{event}")
+
+    # An Influxdb 0.9 event looks like this: 
+    # cpu_load_short,host=server01,region=us-west value=0.64 1434055562000000000
+    #  ^ measurement  ^ tags (optional)            ^ fields   ^ timestamp (optional)
+    # 
+    # Since we'll be buffering them to send as a batch, we'll only collect
+    # the values going into the points array
+    
+    time  = timestamp_at_precision(event.timestamp, @time_precision.to_sym)
+    point = create_point_from_event(event)
+
+    if point.has_key?('time')
       unless @allow_time_override
         logger.error("Cannot override value of time without 'allow_time_override'. Using event timestamp")
-        sprintf_points['time'] = event.timestamp.to_i
+      else
+        time = point.delete("time")
       end
-    else
-      sprintf_points['time'] = event.timestamp.to_i
     end
 
-    @coerce_values.each do |column, value_type|
-      if sprintf_points.has_key?(column)
-        begin
-          case value_type
-          when "integer"
-            @logger.debug? and @logger.debug("Converting column #{column} to type #{value_type}: Current value: #{sprintf_points[column]}")
-            sprintf_points[column] = sprintf_points[column].to_i
-          when "float"
-            @logger.debug? and @logger.debug("Converting column #{column} to type #{value_type}: Current value: #{sprintf_points[column]}")
-            sprintf_points[column] = sprintf_points[column].to_f
-          else
-            @logger.error("Don't know how to convert to #{value_type}")
-          end
-        rescue => e
-          @logger.error("Unhandled exception", :error => e.message)
-        end
-      end
-    end
+    exclude_fields!(point)
+    coerce_values!(point)
 
-    event_hash['columns'] = sprintf_points.keys
-    event_hash['points'] = []
-    event_hash['points'] << sprintf_points.values
+    tags, point = extract_tags(point)
+
+    event_hash = {
+      "measurement" => event.sprintf(@measurement),
+      "time"        => time,
+      "fields"      => point
+    }
+    event_hash["tags"] = tags unless tags.empty?
 
     buffer_receive(event_hash)
   end # def receive
 
+
   def flush(events, teardown = false)
-    # seen_series stores a list of series and associated columns
-    # we've seen for each event
-    # so that we can attempt to batch up points for a given series.
-    #
-    # Columns *MUST* be exactly the same
-    seen_series = {}
-    event_collection = []
-
-    events.each do |ev|
-      begin
-        if seen_series.has_key?(ev['name']) and (seen_series[ev['name']] == ev['columns'])
-          @logger.info("Existing series data found. Appending points to that series")
-          event_collection.select {|h| h['points'] << ev['points'][0] if h['name'] == ev['name']}
-        elsif seen_series.has_key?(ev['name']) and (seen_series[ev['name']] != ev['columns'])
-          @logger.warn("Series '#{ev['name']}' has been seen but columns are different or in a different order. Adding to batch but not under existing series")
-          @logger.warn("Existing series columns were: #{seen_series[ev['name']].join(",")} and event columns were: #{ev['columns'].join(",")}")
-          event_collection << ev
-        else
-          seen_series[ev['name']] = ev['columns']
-          event_collection << ev
-        end
-      rescue => e
-        @logger.warn("Error adding event to collection", :exception => e)
-        next
-      end
-    end
+    @logger.debug? and @logger.debug("Flushing #{events.size} events to #{@url} - Teardown? #{teardown}")
+    post(events_to_request_body(events))
+  end # def flush
 
-    post(LogStash::Json.dump(event_collection))
-  end # def receive_bulk
 
   def post(body)
     begin
-      @logger.debug("Post body: #{body}")
-      response = @agent.post!(@url, :body => body)
+      @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
     end
 
-    # 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
+    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
 
-    if response.status != 200
+    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
 
   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
+  # value (which will be passed through)
+  def create_point_from_event(event)
+    Hash[ (@use_event_fields_for_data_points ? event.to_hash : @data_points).map do |k,v| 
+      [event.sprintf(k), (String === v ? event.sprintf(v) : v)] 
+    end ]
+  end
+  
+
+  # Coerce values in the event data to their appropriate type. This requires 
+  # foreknowledge of what's in the data point, which is less than ideal. An 
+  # alternative is to use a `code` filter and manipulate the individual point's
+  # data before sending to the output pipeline
+  def coerce_values!(event_data)
+    @coerce_values.each do |column, value_type|
+      if event_data.has_key?(column)
+        begin
+          @logger.debug? and @logger.debug("Converting column #{column} to type #{value_type}: Current value: #{event_data[column]}")
+          event_data[column] = coerce_value(value_type, event_data[column])
+
+        rescue => e
+          @logger.error("Unhandled exception", :error => e.message)
+        end
+      end
+    end
+
+    event_data
+  end
+
+
+  def coerce_value(value_type, value)
+    case value_type.to_sym
+    when :integer
+      value.to_i
+      
+    when :float
+      value.to_f
+
+    when :string
+      value.to_s
+    
+    else
+      @logger.warn("Don't know how to convert to #{value_type}. Returning value unchanged")
+      value  
+    end
+  end
+
+
+  # Remove a set of fields from the event data before sending it to Influxdb. This
+  # is useful for removing @timestamp, @version, etc
+  def exclude_fields!(event_data)
+    @exclude_fields.each { |field| event_data.delete(field) }
+  end
+
+
+  # Extract tags from a hash of fields. 
+  # Returns a tuple containing a hash of tags (as configured by send_as_tags) 
+  # and a hash of fields that exclude the tags. If fields contains a key 
+  # "tags" with an array, they will be moved to the tags hash (and each will be
+  # given a value of true)
+  # 
+  # Example: 
+  #   # Given send_as_tags: ["bar"]
+  #   original_fields = {"foo" => 1, "bar" => 2, "tags" => ["tag"]}
+  #   tags, fields = extract_tags(original_fields)
+  #   # tags: {"bar" => 2, "tag" => "true"} and fields: {"foo" => 1}
+  def extract_tags(fields)
+    remainder = fields.dup
+
+    tags = if remainder.has_key?("tags") && remainder["tags"].respond_to?(:inject)
+      remainder.delete("tags").inject({}) { |tags, tag| tags[tag] = "true"; tags }
+    else
+      {}
+    end
+    
+    @send_as_tags.each { |key| (tags[key] = remainder.delete(key)) if remainder.has_key?(key) }
+
+    tags.delete_if { |key,value| value.nil? || value == "" }
+    remainder.delete_if { |key,value| value.nil? || value == "" }
+
+    [tags, remainder]
+  end
+
+
+  # Returns the numeric value of the given timestamp in the requested precision.
+  # precision must be one of the valid values for time_precision
+  def timestamp_at_precision( timestamp, precision )
+    multiplier = case precision
+      when :h  then 1.0/3600
+      when :m  then 1.0/60
+      when :s  then 1
+      when :ms then 1000
+      when :u  then 1000000
+    end
+    
+    (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,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-output-influxdb'
-  s.version         = '2.0.2'
+  s.version         = '3.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/plugin install gemname. This gem is not a stand-alone program"
@@ -23,7 +23,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "logstash-core", ">= 2.0.0.beta2", "< 3.0.0"
 
   s.add_runtime_dependency 'stud'
-  s.add_runtime_dependency 'ftw', ['~> 0.0.40']
+  s.add_runtime_dependency 'manticore'
 
   s.add_development_dependency 'logstash-devutils'
   s.add_development_dependency 'logstash-input-generator'

data/spec/outputs/influxdb_spec.rb

@@ -1,5 +1,6 @@
 require "logstash/devutils/rspec/spec_helper"
 require "logstash/outputs/influxdb"
+require "manticore"
 
 describe LogStash::Outputs::InfluxDB do
 
@@ -25,7 +26,7 @@ describe LogStash::Outputs::InfluxDB do
 
     before do
       subject.register
-      allow(subject).to receive(:post).with(json_result)
+      allow(subject).to receive(:post).with(result)
 
       2.times do
         subject.receive(LogStash::Event.new("foo" => "1", "bar" => "2", "time" => "3", "type" => "generator"))
@@ -35,11 +36,322 @@ describe LogStash::Outputs::InfluxDB do
       subject.close
     end
 
-    let(:json_result) { "[{\"name\":\"logstash\",\"columns\":[\"foo\",\"bar\",\"time\"],\"points\":[[\"1\",\"2\",\"3\"],[\"1\",\"2\",\"3\"]]}]" }
+    let(:result) { "logstash foo=\"1\",bar=\"2\" 3\nlogstash foo=\"1\",bar=\"2\" 3" }
 
     it "should receive 2 events, flush and call post with 2 items json array" do
-      expect(subject).to have_received(:post).with(json_result)
+      expect(subject).to have_received(:post).with(result)
     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
+    end
+
+    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
+    let(:expected_body) { 'my_series foo="1",bar="2" 3' }
+
+    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
+
+  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
+    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' }
+
+    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 "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
+
+    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 "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
+    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 "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
+    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 "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
+
+    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' }
+
+    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 "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
+    end
+
+    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
+    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
+    end
+
+    let(:expected_url)  { 'http://localhost:8086/write?db=statistics&rp=default&precision=ms&u=&p='}
+    let(:expected_body) { 'my_series foo=1,bar=2.0,baz="\\\"quotes\\\"" 3' } # We want the backslash and the escaped-quote in the request body
+
+    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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-influxdb
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-10-14 00:00:00.000000000 Z
+date: 2016-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -47,17 +47,17 @@ dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.0.40
-  name: ftw
+        version: '0'
+  name: manticore
   prerelease: false
   type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.0.40
+        version: '0'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -137,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5
 signing_key:
 specification_version: 4
 summary: This output lets you output Metrics to InfluxDB