fluent-plugin-influxdb-v2 1.5.0.pre.579

data/fluent-plugin-influxdb-v2.gemspec

@@ -0,0 +1,61 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fluent/plugin/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fluent-plugin-influxdb-v2'
+  spec.version       = if ENV['CIRCLE_BUILD_NUM']
+                         "#{InfluxDB2::Plugin::Fluent::VERSION}-#{ENV['CIRCLE_BUILD_NUM']}"
+                       else
+                         InfluxDB2::Plugin::Fluent::VERSION
+                       end
+  spec.authors       = ['Jakub Bednar']
+  spec.email         = ['jakub.bednar@gmail.com']
+
+  spec.summary       = 'InfluxDB 2 output plugin for Fluentd'
+  spec.description   = 'A buffered output plugin for Fluentd and InfluxDB 2'
+  spec.homepage      = 'https://github.com/influxdata/influxdb-plugin-fluent'
+  spec.license       = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/influxdata/influxdb-plugin-fluent'
+  spec.metadata['changelog_uri'] = 'https://raw.githubusercontent.com/influxdata/influxdb-plugin-fluent/master/CHANGELOG.md'
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features|smoke)/})
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.2.0'
+
+  spec.add_runtime_dependency 'fluentd', '~> 1.8'
+  spec.add_runtime_dependency 'influxdb-client', '1.6.0'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'codecov', '~> 0.1.16'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.4'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
+  spec.add_development_dependency 'rubocop', '~> 0.66.0'
+  spec.add_development_dependency 'simplecov', '~> 0.17.1'
+  spec.add_development_dependency 'test-unit', '~> 3.3'
+  spec.add_development_dependency 'webmock', '~> 3.7'
+end

data/lib/fluent/plugin/fluent.rb

@@ -0,0 +1,22 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'fluent/plugin/version'
+require 'fluent/plugin/out_influxdb2'

data/lib/fluent/plugin/out_influxdb2.rb

@@ -0,0 +1,160 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'fluent/plugin/output'
+require 'influxdb-client'
+
+# A buffered output plugin for Fluentd and InfluxDB 2
+class InfluxDBOutput < Fluent::Plugin::Output
+  Fluent::Plugin.register_output('influxdb2', self)
+
+  helpers :inject, :compat_parameters
+
+  DEFAULT_BUFFER_TYPE = 'memory'.freeze
+
+  config_param :url, :string, default: 'https://localhost:9999'
+  desc 'InfluxDB URL to connect to (ex. https://localhost:9999).'
+
+  config_param :token, :string
+  desc 'Access Token used for authenticating/authorizing the InfluxDB request sent by client.'
+
+  config_param :use_ssl, :bool, default: true
+  desc 'Turn on/off SSL for HTTP communication.'
+
+  config_param :bucket, :string
+  desc 'Specifies the destination bucket for writes.'
+
+  config_param :org, :string
+  desc 'Specifies the destination organization for writes.'
+
+  config_param :measurement, :string, default: nil
+  desc 'The name of the measurement. If not specified, Fluentd\'s tag is used.'
+
+  config_param :tag_keys, :array, default: []
+  desc 'The list of record keys that are stored in InfluxDB as \'tag\'.'
+
+  config_param :tag_fluentd, :bool, default: false
+  desc 'Specifies if the Fluentd\'s event tag is included into InfluxDB tags (ex. \'fluentd=system.logs\').'
+
+  config_param :field_keys, :array, default: []
+  desc 'The list of record keys that are stored in InfluxDB as \'field\'. ' \
+      'If it\'s not specified than as fields are used all record keys.'
+
+  config_param :field_cast_to_float, :bool, default: false
+  desc 'Turn on/off auto casting Integer value to Float. ' \
+      'Helper to avoid mismatch error: \'series type mismatch: already Integer but got Float\'.'
+
+  config_param :time_precision, :string, default: 'ns'
+  desc 'The time precision of timestamp. You should specify either second (s), ' \
+      'millisecond (ms), microsecond (us), or nanosecond (ns).'
+
+  config_param :time_key, :string, default: nil
+  desc 'A name of the record key that used as a \'timestamp\' instead of event timestamp.' \
+      'If a record key doesn\'t exists or hasn\'t value then is used event timestamp.'
+
+  config_section :buffer do
+    config_set_default :@type, DEFAULT_BUFFER_TYPE
+    config_set_default :chunk_keys, ['tag']
+  end
+
+  def configure(conf)
+    compat_parameters_convert(conf, :inject)
+    super
+    case @time_precision
+    when 'ns' then
+      @precision_formatter = ->(ns_time) { ns_time }
+    when 'us' then
+      @precision_formatter = ->(ns_time) { (ns_time / 1e3).round }
+    when 'ms' then
+      @precision_formatter = ->(ns_time) { (ns_time / 1e6).round }
+    when 's' then
+      @precision_formatter = ->(ns_time) { (ns_time / 1e9).round }
+    else
+      raise Fluent::ConfigError, "The time precision #{@time_precision} is not supported. You should use: " \
+                                 'second (s), millisecond (ms), microsecond (us), or nanosecond (ns).'
+    end
+    @precision = InfluxDB2::WritePrecision.new.get_from_value(@time_precision)
+    raise Fluent::ConfigError, 'The InfluxDB URL should be defined.' if @url.empty?
+  end
+
+  def start
+    super
+    log.info  "Connecting to InfluxDB: url: #{@url}, bucket: #{@bucket}, org: #{@org}, precision = #{@precision}, " \
+              "use_ssl = #{@use_ssl}"
+    @client = InfluxDB2::Client.new(@url, @token, bucket: @bucket, org: @org, precision: @precision, use_ssl: @use_ssl)
+    @write_api = @client.create_write_api
+  end
+
+  def shutdown
+    super
+    @client.close!
+  end
+
+  def multi_workers_ready?
+    true
+  end
+
+  def write(chunk)
+    points = []
+    tag = chunk.metadata.tag
+    measurement = @measurement || tag
+    chunk.msgpack_each do |time, record|
+      if time.is_a?(Integer)
+        time_formatted = time
+      else
+        nano_seconds = time.sec * 1e9
+        nano_seconds += time.nsec
+        time_formatted = @precision_formatter.call(nano_seconds)
+      end
+      point = InfluxDB2::Point
+              .new(name: measurement)
+      record.each_pair do |k, v|
+        if k.eql?(@time_key)
+          time_formatted = v
+        else
+          _parse_field(k, v, point)
+        end
+        point.add_tag('fluentd', tag) if @tag_fluentd
+      end
+      point.time(time_formatted, @precision)
+      points << point
+    end
+    @write_api.write(data: points)
+    log.debug "Written points: #{points}"
+  end
+
+  private
+
+  def _parse_field(key, value, point)
+    if @tag_keys.include?(key)
+      point.add_tag(key, value)
+    elsif @field_keys.empty? || @field_keys.include?(key)
+      if @field_cast_to_float & value.is_a?(Integer)
+        point.add_field(key, Float(value))
+      elsif value.is_a?(Hash)
+        value.each_pair do |nested_k, nested_v|
+          _parse_field("#{key}.#{nested_k}", nested_v, point)
+        end
+      else
+        point.add_field(key, value)
+      end
+    end
+  end
+end

data/lib/fluent/plugin/version.rb

@@ -0,0 +1,27 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module InfluxDB2
+  module Plugin
+    module Fluent
+      VERSION = '1.5.0'.freeze
+    end
+  end
+end

data/test/influxdb/plugin/output_test.rb

@@ -0,0 +1,443 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'test_helper'
+
+class InfluxDBOutputTest < Minitest::Test
+  include Fluent::Test::Helpers
+  class MockInfluxDBOutput < InfluxDBOutput
+    attr_reader :client
+
+    def write(chunk)
+      super
+    end
+  end
+
+  def setup
+    Fluent::Test.setup
+    WebMock.disable_net_connect!
+  end
+
+  def default_config
+    %(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      time_precision ns
+    )
+  end
+
+  def create_driver(conf = default_config)
+    Fluent::Test::Driver::Output.new(MockInfluxDBOutput).configure(conf)
+  end
+
+  def test_configuration
+    driver = create_driver
+    driver.run(default_tag: 'input.influxdb2') do
+    end
+    assert_equal driver.instance.multi_workers_ready?, true
+  end
+
+  def test_time_precision_parameter
+    refute_nil create_driver
+    conf = %(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      time_precision %s
+    )
+    refute_nil create_driver(format(conf, 'ns'))
+    refute_nil create_driver(format(conf, 'us'))
+    refute_nil create_driver(format(conf, 'ms'))
+    refute_nil create_driver(format(conf, 's'))
+    error = assert_raises Fluent::ConfigError do
+      create_driver(format(conf, 'h'))
+    end
+
+    assert_equal 'The time precision h is not supported. You should use: second (s), millisecond (ms), ' \
+                 'microsecond (us), or nanosecond (ns).', error.message
+  end
+
+  def test_url_parameter
+    error = assert_raises Fluent::ConfigError do
+      create_driver(%(
+        @type influxdb2
+        url
+        token my-token
+        bucket my-bucket
+        org my-org
+    ))
+    end
+
+    assert_equal 'The InfluxDB URL should be defined.', error.message
+  end
+
+  def test_token_parameter
+    error = assert_raises Fluent::ConfigError do
+      create_driver(%(
+        @type influxdb2
+        bucket my-bucket
+        org my-org
+    ))
+    end
+
+    assert_equal '\'token\' parameter is required', error.message
+  end
+
+  def test_use_ssl_parameter
+    error = assert_raises Fluent::ConfigError do
+      create_driver(%(
+        @type influxdb2
+        bucket my-bucket
+        org my-org
+        token my-token
+        use_ssl not_bool
+    ))
+    end
+
+    assert_equal '\'use_ssl\' parameter is required but nil is specified', error.message
+  end
+
+  def test_bucket_parameter
+    error = assert_raises Fluent::ConfigError do
+      create_driver(%(
+      @type influxdb2
+      token my-token
+      org my-org
+      time_precision ns
+    ))
+    end
+
+    assert_equal '\'bucket\' parameter is required', error.message
+  end
+
+  def test_org_parameter
+    error = assert_raises Fluent::ConfigError do
+      create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      time_precision ns
+    ))
+    end
+
+    assert_equal '\'org\' parameter is required', error.message
+  end
+
+  def test_has_client
+    driver = create_driver
+    driver.run(default_tag: 'input.influxdb2') do
+    end
+    refute_nil driver.instance.client
+  end
+
+  def test_measurement_as_parameter
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      measurement h2o
+      time_precision ns
+    ))
+    driver.run(default_tag: 'test') do
+      emit_documents(driver)
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: 'h2o level=2i,location="europe" 1444897215000000000')
+  end
+
+  def test_measurement_as_tag
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      time_precision ns
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver)
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: 'h2o_tag level=2i,location="europe" 1444897215000000000')
+  end
+
+  def test_tag_keys
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      tag_keys ["location"]
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver)
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: 'h2o_tag,location=europe level=2i 1444897215000000000')
+  end
+
+  def test_tag_fluentd
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      measurement h2o
+      tag_keys ["location"]
+      tag_fluentd true
+    ))
+    driver.run(default_tag: 'system.logs') do
+      emit_documents(driver)
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: 'h2o,fluentd=system.logs,location=europe level=2i 1444897215000000000')
+  end
+
+  def test_field_keys
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      tag_keys ["location"]
+      field_keys ["level"]
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver, 'location' => 'europe', 'level' => 2, 'version' => 'v.10')
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: 'h2o_tag,location=europe level=2i 1444897215000000000')
+  end
+
+  def test_time_precision_ns
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      tag_keys ["version"]
+      time_precision ns
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver, 'location' => 'europe', 'level' => 2, 'version' => 'v.10')
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: 'h2o_tag,version=v.10 level=2i,location="europe" 1444897215000000000')
+  end
+
+  def test_time_integer
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      driver.feed(123_465_789, 'location' => 'europe', 'level' => 2, 'version' => 'v.10')
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: 'h2o_tag level=2i,location="europe",version="v.10" 123465789')
+  end
+
+  def test_time_precision_us
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=us')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      tag_keys ["version"]
+      time_precision us
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver, 'location' => 'europe', 'level' => 2, 'version' => 'v.10')
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=us',
+                     times: 1, body: 'h2o_tag,version=v.10 level=2i,location="europe" 1444897215000000')
+  end
+
+  def test_time_precision_ms
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ms')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      tag_keys ["version"]
+      time_precision ms
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver, 'location' => 'europe', 'level' => 2, 'version' => 'v.10')
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ms',
+                     times: 1, body: 'h2o_tag,version=v.10 level=2i,location="europe" 1444897215000')
+  end
+
+  def test_time_precision_s
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=s')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      tag_keys ["version"]
+      time_precision s
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver, 'location' => 'europe', 'level' => 2, 'version' => 'v.10')
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=s',
+                     times: 1, body: 'h2o_tag,version=v.10 level=2i,location="europe" 1444897215')
+  end
+
+  def test_time_key
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      tag_keys ["version"]
+      time_key time
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver, 'location' => 'europe', 'level' => 2, 'version' => 'v.10',
+                             'time' => 1_544_897_215_000_000_000)
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: 'h2o_tag,version=v.10 level=2i,location="europe" 1544897215000000000')
+  end
+
+  def test_field_cast_to_float
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      field_cast_to_float true
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver)
+    end
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: 'h2o_tag level=2.0,location="europe" 1444897215000000000')
+  end
+
+  def test_nested_field
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      time_precision ns
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver, 'location' => 'europe', 'level' => 2,
+                             'nest' => { 'key' => 'nested value', 'deep' => { 'deep-key' => 'deep-value' }, 'a' => 25 })
+    end
+    body = 'h2o_tag level=2i,location="europe",nest.a=25i,nest.deep.deep-key="deep-value",nest.key="nested value" ' \
+'1444897215000000000'
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: body)
+  end
+
+  def test_kubernetes_structure
+    record = {
+      'docker' => { 'container_id' => '7ee0723e90d13df5ade6f5d524f23474461fcfeb48a90630d8b02b13c741550b' },
+      'kubernetes' => { 'container_name' => 'fluentd',
+                        'namespace_name' => 'default',
+                        'pod_name' => 'fluentd-49xk2',
+                        'container_image' => 'rawkode/fluentd:1',
+                        'container_image_id' =>
+                            'docker://sha256:90c288b8a09cc6ae98b04078afb10d9c380c0603a47745403461435073460f97',
+                        'pod_id' => 'c15ab1cb-0773-4ad7-a58b-f791ab34c62f',
+                        'host' => 'minikube',
+                        'labels' => {
+                          'controller-revision-hash' => '57748799f7',
+                          'pod-template-generation' => 2,
+                          'app_kubernetes_io/instance' => 'fluentd',
+                          'app_kubernetes_io/name' => 'fluentd'
+                        },
+                        'master_url' => 'https://10.96.0.1:443/api',
+                        'namespace_id' => '2b0bc75c-323a-4f04-9eec-02255a8d0044' },
+      'log' => '2020-06-17 13:19:42 +0000 [info]: #0 [filter_kube_metadata] stats - namespace_cache_size: 2, '\
+'pod_cache_size: 6, pod_cache_watch_updates: 1, namespace_cache_api_updates: 6, '\
+'pod_cache_api_updates: 6, id_cache_miss: 6\n',
+      'stream' => 'stdout'
+    }
+
+    stub_request(:any, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+    driver = create_driver(%(
+      @type influxdb2
+      token my-token
+      bucket my-bucket
+      org my-org
+      time_precision ns
+    ))
+    driver.run(default_tag: 'h2o_tag') do
+      emit_documents(driver, record)
+    end
+    body = 'h2o_tag docker.container_id="7ee0723e90d13df5ade6f5d524f23474461fcfeb48a90630d8b02b13c741550b",'\
+'kubernetes.container_image="rawkode/fluentd:1",'\
+'kubernetes.container_image_id="docker://sha256:90c288b8a09cc6ae98b04078afb10d9c380c0603a47745403461435073460f97",'\
+'kubernetes.container_name="fluentd",kubernetes.host="minikube",'\
+'kubernetes.labels.app_kubernetes_io/instance="fluentd",kubernetes.labels.app_kubernetes_io/name="fluentd",'\
+'kubernetes.labels.controller-revision-hash="57748799f7",kubernetes.labels.pod-template-generation=2i,'\
+'kubernetes.master_url="https://10.96.0.1:443/api",kubernetes.namespace_id="2b0bc75c-323a-4f04-9eec-02255a8d0044",'\
+'kubernetes.namespace_name="default",kubernetes.pod_id="c15ab1cb-0773-4ad7-a58b-f791ab34c62f",'\
+'kubernetes.pod_name="fluentd-49xk2",log="2020-06-17 13:19:42 +0000 [info]: #0 [filter_kube_metadata] stats - '\
+'namespace_cache_size: 2, pod_cache_size: 6, pod_cache_watch_updates: 1, namespace_cache_api_updates: 6, '\
+'pod_cache_api_updates: 6, id_cache_miss: 6\\\n",stream="stdout" 1444897215000000000'
+    assert_requested(:post, 'https://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: body)
+  end
+
+  def emit_documents(driver, data = { 'location' => 'europe', 'level' => 2 })
+    time = event_time('2015-10-15 8:20:15 UTC')
+    driver.feed(time, data)
+    time
+  end
+end