RubyGems - fluent-plugin-geoip - Versions diffs - 1.0.0 → 1.3.2 - Mend

fluent-plugin-geoip 1.0.0 → 1.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

checksums.yaml +5 -5
data/.github/ISSUE_TEMPLATE.md +19 -0
data/.travis.yml +1 -1
data/README.md +203 -239
data/docker-compose.yml +12 -5
data/dockerfiles/Dockerfile-ruby2.1 +1 -1
data/dockerfiles/Dockerfile-ruby2.2 +1 -1
data/dockerfiles/Dockerfile-ruby2.3 +1 -1
data/dockerfiles/Dockerfile-ruby2.4 +1 -1
data/dockerfiles/Dockerfile-ruby2.5 +8 -0
data/fluent-plugin-geoip.gemspec +2 -1
data/lib/fluent/plugin/filter_geoip.rb +196 -11
data/test/helper.rb +1 -0
data/test/plugin/test_filter_geoip.rb +296 -107
data/utils/dump.rb +27 -0
metadata +20 -8
data/lib/fluent/plugin/geoip.rb +0 -174
data/lib/fluent/plugin/out_geoip.rb +0 -51
data/test/plugin/test_out_geoip.rb +0 -1076

data/utils/dump.rb ADDED

@@ -0,0 +1,27 @@
+#! /usr/bin/env ruby
+require "geoip"
+require "geoip2_compat"
+require "geoip2"
+require "pp"
+backend = ARGV[0]
+ip = ARGV[1]
+geoip_database = File.expand_path("../data/GeoLiteCity.dat", __dir__)
+geoip2_database = File.expand_path("../data/GeoLite2-City.mmdb", __dir__)
+geoip = GeoIP::City.new(geoip_database, :memory, false)
+geoip2_compat = GeoIP2Compat.new(geoip2_database)
+geoip2 = GeoIP2::Database.new(geoip2_database)
+record = case backend
+         when "geoip"
+           geoip.look_up(ip)
+         when "geoip2_compat"
+           geoip2_compat.lookup(ip)
+         when "geoip2"
+           geoip2.lookup(ip)
+         end
+pp record.to_h

metadata CHANGED

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-geoip
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.3.2
 platform: ruby
 authors:
 - Kentaro Yoshida
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-12-19 00:00:00.000000000 Z
+date: 2020-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: test-unit-rr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: geoip2_compat
   requirement: !ruby/object:Gem::Requirement
@@ -149,6 +163,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/ISSUE_TEMPLATE.md"
 - ".gitignore"
 - ".travis.yml"
 - Appraisals
@@ -166,15 +181,14 @@ files:
 - dockerfiles/Dockerfile-ruby2.2
 - dockerfiles/Dockerfile-ruby2.3
 - dockerfiles/Dockerfile-ruby2.4
+- dockerfiles/Dockerfile-ruby2.5
 - fluent-plugin-geoip.gemspec
 - gemfiles/fluentd_v1.0_with_backport_dig.gemfile
 - gemfiles/fluentd_v1.0_without_backport_dig.gemfile
 - lib/fluent/plugin/filter_geoip.rb
-- lib/fluent/plugin/geoip.rb
-- lib/fluent/plugin/out_geoip.rb
 - test/helper.rb
 - test/plugin/test_filter_geoip.rb
-- test/plugin/test_out_geoip.rb
+- utils/dump.rb
 homepage: https://github.com/y-ken/fluent-plugin-geoip
 licenses:
 - Apache-2.0
@@ -194,8 +208,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.6.13
+rubygems_version: 3.0.3
 signing_key:
 specification_version: 4
 summary: Fluentd Filter plugin to add information about geographical location of IP
@@ -203,4 +216,3 @@ summary: Fluentd Filter plugin to add information about geographical location of
 test_files:
 - test/helper.rb
 - test/plugin/test_filter_geoip.rb
-- test/plugin/test_out_geoip.rb

data/lib/fluent/plugin/geoip.rb DELETED

@@ -1,174 +0,0 @@
-require 'geoip'
-require 'yajl'
-unless {}.respond_to?(:dig)
-  begin
-    # backport_dig is faster than dig_rb so prefer backport_dig.
-    # And Fluentd v1.0.1 uses backport_dig
-    require 'backport_dig'
-  rescue LoadError
-    require 'dig_rb'
-  end
-end
-module Fluent
-  class GeoIP
-    BACKEND_LIBRARIES = [:geoip, :geoip2_compat, :geoip2_c]
-    REGEXP_PLACEHOLDER_SINGLE = /^\$\{(?<geoip_key>-?[^\[]+)\[['"](?<record_key>-?[^'"]+)['"]\]\}$/
-    REGEXP_PLACEHOLDER_SCAN = /['"]?(\$\{[^\}]+?\})['"]?/
-    GEOIP_KEYS = %w(city latitude longitude country_code3 country_code country_name dma_code area_code region)
-    GEOIP2_COMPAT_KEYS = %w(city country_code country_name latitude longitude postal_code region region_name)
-    attr_reader :log
-    def initialize(plugin, conf)
-      @map = {}
-      plugin.geoip_lookup_key = plugin.geoip_lookup_key.split(/\s*,\s*/)
-      @geoip_lookup_key = plugin.geoip_lookup_key
-      @skip_adding_null_record = plugin.skip_adding_null_record
-      @log = plugin.log
-      # enable_key_* format (legacy format)
-      conf.keys.select{|k| k =~ /^enable_key_/}.each do |key|
-        geoip_key = key.sub('enable_key_','')
-        raise Fluent::ConfigError, "geoip: unsupported key #{geoip_key}" unless GEOIP_KEYS.include?(geoip_key)
-        @geoip_lookup_key.zip(conf[key].split(/\s*,\s*/)).each do |lookup_field,record_key|
-          if record_key.nil?
-            raise Fluent::ConfigError, "geoip: missing value found at '#{key} #{lookup_field}'"
-          end
-          @map[record_key] = "${#{geoip_key}['#{lookup_field}']}"
-        end
-      end
-      if conf.keys.select{|k| k =~ /^enable_key_/}.size > 0
-        log.warn "geoip: 'enable_key_*' config format is obsoleted. use <record></record> directive for now."
-        log.warn "geoip: for further details referable to https://github.com/y-ken/fluent-plugin-geoip"
-      end
-      # <record></record> directive
-      conf.elements.select { |element| element.name == 'record' }.each { |element|
-        element.each_pair { |k, v|
-          element.has_key?(k) # to suppress unread configuration warning
-          v = v[1..v.size-2] if quoted_value?(v)
-          @map[k] = v
-          validate_json = Proc.new {
-            begin
-              dummy_text = Yajl::Encoder.encode('dummy_text')
-              Yajl::Parser.parse(v.gsub(REGEXP_PLACEHOLDER_SCAN, dummy_text))
-            rescue Yajl::ParseError => e
-              raise Fluent::ConfigError, "geoip: failed to parse '#{v}' as json."
-            end
-          }
-          validate_json.call if json?(v.tr('\'"\\', ''))
-        }
-      }
-      @placeholder_keys = @map.values.join.scan(REGEXP_PLACEHOLDER_SCAN).map{ |placeholder| placeholder[0] }.uniq
-      @placeholder_keys.each do |key|
-        geoip_key = key.match(REGEXP_PLACEHOLDER_SINGLE)[:geoip_key]
-        case plugin.backend_library
-        when :geoip
-          raise Fluent::ConfigError, "#{plugin.backend_library}: unsupported key #{geoip_key}" unless GEOIP_KEYS.include?(geoip_key)
-        when :geoip2_compat
-          raise Fluent::ConfigError, "#{plugin.backend_library}: unsupported key #{geoip_key}" unless GEOIP2_COMPAT_KEYS.include?(geoip_key)
-        when :geoip2_c
-          # Nothing to do.
-          # We cannot define supported key(s) before we fetch values from GeoIP2 database
-          # because geoip2_c can fetch any fields in GeoIP2 database.
-        end
-      end
-      @geoip = load_database(plugin)
-    end
-    def add_geoip_field(record)
-      placeholder = create_placeholder(geolocate(get_address(record)))
-      return record if @skip_adding_null_record && placeholder.values.first.nil?
-      @map.each do |record_key, value|
-        if value.match(REGEXP_PLACEHOLDER_SINGLE)
-          rewrited = placeholder[value]
-        elsif json?(value)
-          rewrited = value.gsub(REGEXP_PLACEHOLDER_SCAN) {|match|
-            match = match[1..match.size-2] if quoted_value?(match)
-            Yajl::Encoder.encode(placeholder[match])
-          }
-          rewrited = parse_json(rewrited)
-        else
-          rewrited = value.gsub(REGEXP_PLACEHOLDER_SCAN, placeholder)
-        end
-        record[record_key] = rewrited
-      end
-      return record
-    end
-    private
-    def json?(text)
-      text.match(/^\[.+\]$/) || text.match(/^\{.+\}$/)
-    end
-    def quoted_value?(text)
-      # to improbe compatibility with fluentd v1-config
-      trim_quote = text[1..text.size-2]
-      text.match(/(^'.+'$|^".+"$)/)
-    end
-    def parse_json(message)
-      begin
-        return Yajl::Parser.parse(message)
-      rescue Yajl::ParseError => e
-        log.info "geoip: failed to parse '#{message}' as json.", error_class: e.class, error: e.message
-        return nil
-      end
-    end
-    def get_address(record)
-      address = {}
-      @geoip_lookup_key.each do |field|
-        address[field] = record[field] || record.dig(*field.split('.'))
-      end
-      address
-    end
-    def geolocate(addresses)
-      geodata = {}
-      addresses.each do |field, ip|
-        geo = nil
-        if ip
-          geo = if @geoip.respond_to?(:look_up)
-                  @geoip.look_up(ip)
-                else
-                  @geoip.lookup(ip)
-                end
-        end
-        geodata[field] = geo
-      end
-      geodata
-    end
-    def create_placeholder(geodata)
-      placeholder = {}
-      @placeholder_keys.each do |placeholder_key|
-        position = placeholder_key.match(REGEXP_PLACEHOLDER_SINGLE)
-        next if position.nil? or geodata[position[:record_key]].nil?
-        keys = [position[:record_key]] + position[:geoip_key].split('.').map(&:to_sym)
-        placeholder[placeholder_key] = geodata.dig(*keys)
-      end
-      placeholder
-    end
-    def load_database(plugin)
-      case plugin.backend_library
-      when :geoip
-        ::GeoIP::City.new(plugin.geoip_database, :memory, false)
-      when :geoip2_compat
-        require 'geoip2_compat'
-        GeoIP2Compat.new(plugin.geoip2_database)
-      when :geoip2_c
-        require 'geoip2'
-        GeoIP2::Database.new(plugin.geoip2_database)
-      end
-    rescue LoadError
-      raise Fluent::ConfigError, "You must install #{plugin.backend_library} gem."
-    end
-  end
-end

data/lib/fluent/plugin/out_geoip.rb DELETED

@@ -1,51 +0,0 @@
-require 'fluent/plugin/output'
-require 'fluent/plugin/geoip'
-class Fluent::Plugin::GeoipOutput < Fluent::Plugin::Output
-  Fluent::Plugin.register_output('geoip', self)
-  helpers :event_emitter, :inject, :compat_parameters
-  config_param :geoip_database, :string, default: File.dirname(__FILE__) + '/../../../data/GeoLiteCity.dat'
-  config_param :geoip2_database, :string, default: File.dirname(__FILE__) + '/../../../data/GeoLite2-City.mmdb'
-  config_param :geoip_lookup_key, :string, default: 'host'
-  config_param :tag, :string, default: nil
-  config_param :skip_adding_null_record, :bool, default: false
-  config_param :flush_interval, :time, default: 0
-  config_param :log_level, :string, default: 'warn'
-  config_param :backend_library, :enum, list: Fluent::GeoIP::BACKEND_LIBRARIES, default: :geoip2_c
-  config_section :buffer do
-    config_set_default :@type, :memory
-    config_set_default :chunk_keys, ['tag']
-  end
-  def configure(conf)
-    compat_parameters_convert(conf, :buffer, default_chunk_key: 'tag')
-    super
-    raise Fluetn::ConfigError, "chunk key must include 'tag'" unless @chunk_key_tag
-    placeholder_validate!(:tag, @tag) if @tag
-    @geoip = Fluent::GeoIP.new(self, conf)
-  end
-  def format(tag, time, record)
-    record = inject_values_to_record(tag, time, record)
-    [tag, time, record].to_msgpack
-  end
-  def formatted_to_msgpack_binary
-    true
-  end
-  def write(chunk)
-    es = Fluent::MultiEventStream.new
-    tag = ""
-    chunk.each do |_tag, time, record|
-      tag = _tag
-      es.add(time, @geoip.add_geoip_field(record))
-    end
-    tag = extract_placeholders(@tag, chunk.metadata) if @tag
-    router.emit_stream(tag, es)
-  end
-end

data/test/plugin/test_out_geoip.rb DELETED

@@ -1,1076 +0,0 @@
-require 'helper'
-require 'fluent/plugin/out_geoip'
-require 'fluent/test/driver/output'
-class GeoipOutputTest < Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-  end
-  CONFIG = %[
-    geoip_lookup_key  host
-    enable_key_city   geoip_city
-    tag               geoip.${tag[1]}
-  ]
-  def create_driver(conf = CONFIG, syntax: :v1)
-    Fluent::Test::Driver::Output.new(Fluent::Plugin::GeoipOutput).configure(conf, syntax: syntax)
-  end
-  sub_test_case "configure" do
-    test "empty" do
-      assert_nothing_raised do
-        create_driver('')
-      end
-    end
-    test "missing required parameters" do
-      assert_raise(Fluent::ConfigError) {
-        create_driver('enable_key_cities')
-      }
-    end
-    test "minimum" do
-      d = create_driver %[
-        enable_key_city   geoip_city
-        tag               geoip.${tag[1]}
-      ]
-      assert_equal 'geoip_city', d.instance.config['enable_key_city']
-    end
-    test "invalid key name" do
-      assert_raise(Fluent::ConfigError.new("geoip: unsupported key cities")) do
-        create_driver('enable_key_cities')
-      end
-    end
-    test "multiple key config" do
-      d = create_driver %[
-        geoip_lookup_key  from.ip, to.ip
-        enable_key_city   from_city, to_city
-        tag               geoip.${tag[1]}
-      ]
-      assert_equal 'from_city, to_city', d.instance.config['enable_key_city']
-    end
-    test "multiple key config (bad configure)" do
-      assert_raise(Fluent::ConfigError) do
-        create_driver %[
-          geoip_lookup_key  from.ip, to.ip
-          enable_key_city   from_city
-          enable_key_region from_region
-          tag               geoip.${tag[1]}
-        ]
-      end
-    end
-    test "invalid json structure w/ Ruby hash like" do
-      assert_raise(Fluent::ConfigParseError) do
-        create_driver %[
-          geoip_lookup_key  host
-          <record>
-            invalid_json    {"foo" => 123}
-          </record>
-          tag               geoip.${tag[1]}
-        ]
-      end
-    end
-    test "invalid json structure w/ unquoted string literal" do
-      assert_raise(Fluent::ConfigParseError) do
-        create_driver %[
-          geoip_lookup_key  host
-          <record>
-            invalid_json    {"foo" : string, "bar" : 123}
-          </record>
-          tag               geoip.${tag[1]}
-        ]
-      end
-    end
-    data(geoip: "geoip",
-         geoip2_compat: "geoip2_compat")
-    test "unsupported key" do |backend|
-      assert_raise(Fluent::ConfigError.new("#{backend}: unsupported key unknown")) do
-        create_driver %[
-          backend_library #{backend}
-          <record>
-            city ${unknown["host"]}
-          </record>
-          tag               geoip.${tag[1]}
-        ]
-      end
-    end
-    data(geoip: ["geoip", '${city["host"]}'],
-         geoip2_compat: ["geoip2_compat", '${city["host"]}'],
-         geoip2_c: ["geoip2_c", '${city.names.en["host"]}'])
-    test "supported backend" do |(backend, placeholder)|
-      create_driver %[
-        backend_library #{backend}
-        <record>
-          city #{placeholder}
-        </record>
-        tag               geoip.${tag[1]}
-      ]
-    end
-    test "unsupported backend" do
-      assert_raise(Fluent::ConfigError) do
-        create_driver %[
-          backend_library hive_geoip2
-          <record>
-            city ${city["host"]}
-          </record>
-          tag               geoip.${tag[1]}
-        ]
-      end
-    end
-  end
-  sub_test_case "geoip2_c" do
-    def test_emit_tag_option
-      d1 = create_driver(%[
-        backend_library   geoip2_c
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city.names.en['host']}
-        </record>
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['geoip_city']
-      assert_equal nil, events[1][2]['geoip_city']
-    end
-    def test_emit_tag_parts
-      d1 = create_driver(%[
-        backend_library   geoip2_c
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city.names.en['host']}
-        </record>
-        tag               geoip.${tag[1]}.${tag[2]}.${tag[3]}
-      ])
-      d1.run(default_tag: '0.1.2.3') do
-        d1.feed({'host' => '66.102.3.80'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.1.2.3', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['geoip_city']
-    end
-    def test_emit_with_dot_key
-      d1 = create_driver(%[
-        backend_library   geoip2_c
-        geoip_lookup_key  ip.origin, ip.dest
-        <record>
-          origin_country  ${country.iso_code['ip.origin']}
-          dest_country    ${country.iso_code['ip.dest']}
-        </record>
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'ip.origin' => '66.102.3.80', 'ip.dest' => '8.8.8.8'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'US', events[0][2]['origin_country']
-      assert_equal 'US', events[0][2]['dest_country']
-    end
-    def test_emit_with_unknown_address
-      d1 = create_driver(%[
-        backend_library   geoip2_c
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city.names.en['host']}
-          geopoint        [${location.longitude['host']}, ${location.latitude['host']}]
-        </record>
-        skip_adding_null_record false
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        # 203.0.113.1 is a test address described in RFC5737
-        d1.feed({'host' => '203.0.113.1', 'message' => 'invalid ip'})
-        d1.feed({'host' => '0', 'message' => 'invalid ip'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal nil, events[0][2]['geoip_city']
-      assert_equal 'geoip.access', events[1][0] # tag
-      assert_equal nil, events[1][2]['geoip_city']
-    end
-    def test_emit_with_skip_unknown_address
-      d1 = create_driver(%[
-        backend_library   geoip2_c
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city.names.en['host']}
-          geopoint        [${location.longitude['host']}, ${location.latitude['host']}]
-        </record>
-        skip_adding_null_record true
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        # 203.0.113.1 is a test address described in RFC5737
-        d1.feed({'host' => '203.0.113.1', 'message' => 'invalid ip'})
-        d1.feed({'host' => '0', 'message' => 'invalid ip'})
-        d1.feed({'host' => '66.102.3.80', 'message' => 'google bot'})
-      end
-      events = d1.events
-      assert_equal 3, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal nil, events[0][2]['geoip_city']
-      assert_equal nil, events[0][2]['geopoint']
-      assert_equal 'geoip.access', events[1][0] # tag
-      assert_equal nil, events[1][2]['geoip_city']
-      assert_equal nil, events[1][2]['geopoint']
-      assert_equal 'Mountain View', events[2][2]['geoip_city']
-      assert_equal [-122.0574, 37.419200000000004], events[2][2]['geopoint']
-    end
-    def test_emit_record_directive
-      d1 = create_driver(%[
-        backend_library   geoip2_c
-        geoip_lookup_key  from.ip
-        <record>
-          from_city       ${city.names.en['from.ip']}
-          from_country    ${country.names.en['from.ip']}
-          latitude        ${location.latitude['from.ip']}
-          longitude       ${location.longitude['from.ip']}
-          float_concat    ${location.latitude['from.ip']},${location.longitude['from.ip']}
-          float_array     [${location.longitude['from.ip']}, ${location.latitude['from.ip']}]
-          float_nest      { "lat" : ${location.latitude['from.ip']}, "lon" : ${location.longitude['from.ip']}}
-          string_concat   ${location.latitude['from.ip']},${location.longitude['from.ip']}
-          string_array    [${city.names.en['from.ip']}, ${country.names.en['from.ip']}]
-          string_nest     { "city" : ${city.names.en['from.ip']}, "country_name" : ${country.names.en['from.ip']}}
-          unknown_city    ${city.names.en['unknown_key']}
-          undefined       ${city.names.en['undefined']}
-          broken_array1   [${location.longitude['from.ip']}, ${location.latitude['undefined']}]
-          broken_array2   [${location.longitude['undefined']}, ${location.latitude['undefined']}]
-        </record>
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'from' => {'ip' => '66.102.3.80'}})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['from_city']
-      assert_equal 'United States', events[0][2]['from_country']
-      assert_equal 37.419200000000004, events[0][2]['latitude']
-      assert_equal -122.0574, events[0][2]['longitude']
-      assert_equal '37.419200000000004,-122.0574', events[0][2]['float_concat']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['float_array']
-      float_nest = {"lat" => 37.419200000000004, "lon" => -122.0574 }
-      assert_equal float_nest, events[0][2]['float_nest']
-      assert_equal '37.419200000000004,-122.0574', events[0][2]['string_concat']
-      assert_equal ["Mountain View", "United States"], events[0][2]['string_array']
-      string_nest = {"city" => "Mountain View", "country_name" => "United States"}
-      assert_equal string_nest, events[0][2]['string_nest']
-      assert_equal nil, events[0][2]['unknown_city']
-      assert_equal nil, events[0][2]['undefined']
-      assert_equal [-122.0574, nil], events[0][2]['broken_array1']
-      assert_equal [nil, nil], events[0][2]['broken_array2']
-      assert_equal nil, events[1][2]['from_city']
-      assert_equal nil, events[1][2]['from_country']
-      assert_equal nil, events[1][2]['latitude']
-      assert_equal nil, events[1][2]['longitude']
-      assert_equal ',', events[1][2]['float_concat']
-      assert_equal [nil, nil], events[1][2]['float_array']
-      float_nest = {"lat" => nil, "lon" => nil}
-      assert_equal float_nest, events[1][2]['float_nest']
-      assert_equal ',', events[1][2]['string_concat']
-      assert_equal [nil, nil], events[1][2]['string_array']
-      string_nest = {"city" => nil, "country_name" => nil}
-      assert_equal string_nest, events[1][2]['string_nest']
-      assert_equal nil, events[1][2]['unknown_city']
-      assert_equal nil, events[1][2]['undefined']
-      assert_equal [nil, nil], events[1][2]['broken_array1']
-      assert_equal [nil, nil], events[1][2]['broken_array2']
-    end
-    def test_emit_record_directive_multiple_record
-      d1 = create_driver(%[
-        backend_library   geoip2_c
-        geoip_lookup_key  from.ip, to.ip
-        <record>
-          from_city       ${city.names.en['from.ip']}
-          to_city         ${city.names.en['to.ip']}
-          from_country    ${country.names.en['from.ip']}
-          to_country      ${country.names.en['to.ip']}
-          string_array    [${country.names.en['from.ip']}, ${country.names.en['to.ip']}]
-        </record>
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['from_city']
-      assert_equal 'United States', events[0][2]['from_country']
-      assert_equal 'Tokorozawa', events[0][2]['to_city']
-      assert_equal 'Japan', events[0][2]['to_country']
-      assert_equal ['United States','Japan'], events[0][2]['string_array']
-      assert_equal nil, events[1][2]['from_city']
-      assert_equal nil, events[1][2]['to_city']
-      assert_equal nil, events[1][2]['from_country']
-      assert_equal nil, events[1][2]['to_country']
-      assert_equal [nil, nil], events[1][2]['string_array']
-    end
-    def config_quoted_record
-      %[
-      backend_library   geoip2_c
-      geoip_lookup_key  host
-      <record>
-        location_properties  '{ "country_code" : "${country.iso_code["host"]}", "lat": ${location.latitude["host"]}, "lon": ${location.longitude["host"]} }'
-        location_string      ${location.latitude['host']},${location.longitude['host']}
-        location_string2     ${country.iso_code["host"]}
-        location_array       "[${location.longitude['host']},${location.latitude['host']}]"
-        location_array2      '[${location.longitude["host"]},${location.latitude["host"]}]'
-        peculiar_pattern     '[GEOIP] message => {"lat":${location.latitude["host"]}, "lon":${location.longitude["host"]}}'
-      </record>
-      tag               geoip.${tag[1]}
-      ]
-    end
-    def test_emit_quoted_record
-      d1 = create_driver(config_quoted_record)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      location_properties = { "country_code" => "US", "lat" => 37.419200000000004, "lon"=> -122.0574 }
-      assert_equal location_properties, events[0][2]['location_properties']
-      assert_equal '37.419200000000004,-122.0574', events[0][2]['location_string']
-      assert_equal 'US', events[0][2]['location_string2']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['location_array']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['location_array2']
-      assert_equal '[GEOIP] message => {"lat":37.419200000000004, "lon":-122.0574}', events[0][2]['peculiar_pattern']
-    end
-    def test_emit_v1_config_compatibility
-      d1 = create_driver(config_quoted_record)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      location_properties = { "country_code" => "US", "lat" => 37.419200000000004, "lon"=> -122.0574 }
-      assert_equal location_properties, events[0][2]['location_properties']
-      assert_equal '37.419200000000004,-122.0574', events[0][2]['location_string']
-      assert_equal 'US', events[0][2]['location_string2']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['location_array']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['location_array2']
-      assert_equal '[GEOIP] message => {"lat":37.419200000000004, "lon":-122.0574}', events[0][2]['peculiar_pattern']
-    end
-    def test_emit_multiline_v1_config
-      d1 = create_driver(%[
-        backend_library   geoip2_c
-        geoip_lookup_key  host
-        <record>
-          location_properties  {
-            "city": "${city.names.en['host']}",
-            "country_code": "${country.iso_code['host']}",
-            "latitude": "${location.latitude['host']}",
-            "longitude": "${location.longitude['host']}"
-          }
-        </record>
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      location_properties = { "city"=>"Mountain View", "country_code"=>"US", "latitude"=>37.419200000000004, "longitude"=>-122.0574 }
-      assert_equal location_properties, events[0][2]['location_properties']
-    end
-  end
-  sub_test_case "geoip2_compat" do
-    def test_emit_tag_option
-      d1 = create_driver(%[
-        backend_library   geoip2_compat
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city['host']}
-        </record>
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['geoip_city']
-      assert_equal nil, events[1][2]['geoip_city']
-    end
-    def test_emit_tag_parts
-      d1 = create_driver(%[
-        backend_library   geoip2_compat
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city['host']}
-        </record>
-        tag               geoip.${tag[1]}.${tag[2]}.${tag[3]}
-      ])
-      d1.run(default_tag: '0.1.2.3') do
-        d1.feed({'host' => '66.102.3.80'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.1.2.3', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['geoip_city']
-    end
-    def test_emit_with_dot_key
-      d1 = create_driver(%[
-        backend_library   geoip2_compat
-        geoip_lookup_key  ip.origin, ip.dest
-        <record>
-          origin_country  ${country_code['ip.origin']}
-          dest_country    ${country_code['ip.dest']}
-        </record>
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'ip.origin' => '66.102.3.80', 'ip.dest' => '8.8.8.8'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'US', events[0][2]['origin_country']
-      assert_equal 'US', events[0][2]['dest_country']
-    end
-    def test_emit_with_unknown_address
-      d1 = create_driver(%[
-        backend_library   geoip2_compat
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city['host']}
-          geopoint        [${longitude['host']}, ${latitude['host']}]
-        </record>
-        skip_adding_null_record false
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        # 203.0.113.1 is a test address described in RFC5737
-        d1.feed({'host' => '203.0.113.1', 'message' => 'invalid ip'})
-        d1.feed({'host' => '0', 'message' => 'invalid ip'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal nil, events[0][2]['geoip_city']
-      assert_equal 'geoip.access', events[1][0] # tag
-      assert_equal nil, events[1][2]['geoip_city']
-    end
-    def test_emit_with_skip_unknown_address
-      d1 = create_driver(%[
-        backend_library   geoip2_compat
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city['host']}
-          geopoint        [${longitude['host']}, ${latitude['host']}]
-        </record>
-        skip_adding_null_record true
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        # 203.0.113.1 is a test address described in RFC5737
-        d1.feed({'host' => '203.0.113.1', 'message' => 'invalid ip'})
-        d1.feed({'host' => '0', 'message' => 'invalid ip'})
-        d1.feed({'host' => '66.102.3.80', 'message' => 'google bot'})
-      end
-      events = d1.events
-      assert_equal 3, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal nil, events[0][2]['geoip_city']
-      assert_equal nil, events[0][2]['geopoint']
-      assert_equal 'geoip.access', events[1][0] # tag
-      assert_equal nil, events[1][2]['geoip_city']
-      assert_equal nil, events[1][2]['geopoint']
-      assert_equal 'Mountain View', events[2][2]['geoip_city']
-      assert_equal [-122.0574, 37.419200000000004], events[2][2]['geopoint']
-    end
-    def test_emit_record_directive
-      d1 = create_driver(%[
-        backend_library   geoip2_compat
-        geoip_lookup_key  from.ip
-        <record>
-          from_city       ${city['from.ip']}
-          from_country    ${country_name['from.ip']}
-          latitude        ${latitude['from.ip']}
-          longitude       ${longitude['from.ip']}
-          float_concat    ${latitude['from.ip']},${longitude['from.ip']}
-          float_array     [${longitude['from.ip']}, ${latitude['from.ip']}]
-          float_nest      { "lat" : ${latitude['from.ip']}, "lon" : ${longitude['from.ip']}}
-          string_concat   ${latitude['from.ip']},${longitude['from.ip']}
-          string_array    [${city['from.ip']}, ${country_name['from.ip']}]
-          string_nest     { "city" : ${city['from.ip']}, "country_name" : ${country_name['from.ip']}}
-          unknown_city    ${city['unknown_key']}
-          undefined       ${city['undefined']}
-          broken_array1   [${longitude['from.ip']}, ${latitude['undefined']}]
-          broken_array2   [${longitude['undefined']}, ${latitude['undefined']}]
-        </record>
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'from' => {'ip' => '66.102.3.80'}})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['from_city']
-      assert_equal 'United States', events[0][2]['from_country']
-      assert_equal 37.419200000000004, events[0][2]['latitude']
-      assert_equal -122.0574, events[0][2]['longitude']
-      assert_equal '37.419200000000004,-122.0574', events[0][2]['float_concat']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['float_array']
-      float_nest = {"lat" => 37.419200000000004, "lon" => -122.0574 }
-      assert_equal float_nest, events[0][2]['float_nest']
-      assert_equal '37.419200000000004,-122.0574', events[0][2]['string_concat']
-      assert_equal ["Mountain View", "United States"], events[0][2]['string_array']
-      string_nest = {"city" => "Mountain View", "country_name" => "United States"}
-      assert_equal string_nest, events[0][2]['string_nest']
-      assert_equal nil, events[0][2]['unknown_city']
-      assert_equal nil, events[0][2]['undefined']
-      assert_equal [-122.0574, nil], events[0][2]['broken_array1']
-      assert_equal [nil, nil], events[0][2]['broken_array2']
-      assert_equal nil, events[1][2]['from_city']
-      assert_equal nil, events[1][2]['from_country']
-      assert_equal nil, events[1][2]['latitude']
-      assert_equal nil, events[1][2]['longitude']
-      assert_equal ',', events[1][2]['float_concat']
-      assert_equal [nil, nil], events[1][2]['float_array']
-      float_nest = {"lat" => nil, "lon" => nil}
-      assert_equal float_nest, events[1][2]['float_nest']
-      assert_equal ',', events[1][2]['string_concat']
-      assert_equal [nil, nil], events[1][2]['string_array']
-      string_nest = {"city" => nil, "country_name" => nil}
-      assert_equal string_nest, events[1][2]['string_nest']
-      assert_equal nil, events[1][2]['unknown_city']
-      assert_equal nil, events[1][2]['undefined']
-      assert_equal [nil, nil], events[1][2]['broken_array1']
-      assert_equal [nil, nil], events[1][2]['broken_array2']
-    end
-    def test_emit_record_directive_multiple_record
-      d1 = create_driver(%[
-        backend_library   geoip2_compat
-        geoip_lookup_key  from.ip, to.ip
-        <record>
-          from_city       ${city['from.ip']}
-          to_city         ${city['to.ip']}
-          from_country    ${country_name['from.ip']}
-          to_country      ${country_name['to.ip']}
-          string_array    [${country_name['from.ip']}, ${country_name['to.ip']}]
-        </record>
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['from_city']
-      assert_equal 'United States', events[0][2]['from_country']
-      assert_equal 'Tokorozawa', events[0][2]['to_city']
-      assert_equal 'Japan', events[0][2]['to_country']
-      assert_equal ['United States','Japan'], events[0][2]['string_array']
-      assert_equal nil, events[1][2]['from_city']
-      assert_equal nil, events[1][2]['to_city']
-      assert_equal nil, events[1][2]['from_country']
-      assert_equal nil, events[1][2]['to_country']
-      assert_equal [nil, nil], events[1][2]['string_array']
-    end
-    def config_quoted_record
-      %[
-      backend_library   geoip2_compat
-      geoip_lookup_key  host
-      <record>
-        location_properties  '{ "country_code" : "${country_code["host"]}", "lat": ${latitude["host"]}, "lon": ${longitude["host"]} }'
-        location_string      ${latitude['host']},${longitude['host']}
-        location_string2     ${country_code["host"]}
-        location_array       "[${longitude['host']},${latitude['host']}]"
-        location_array2      '[${longitude["host"]},${latitude["host"]}]'
-        peculiar_pattern     '[GEOIP] message => {"lat":${latitude["host"]}, "lon":${longitude["host"]}}'
-      </record>
-      tag               geoip.${tag[1]}
-      ]
-    end
-    def test_emit_quoted_record
-      d1 = create_driver(config_quoted_record)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      location_properties = { "country_code" => "US", "lat" => 37.419200000000004, "lon"=> -122.0574 }
-      assert_equal location_properties, events[0][2]['location_properties']
-      assert_equal '37.419200000000004,-122.0574', events[0][2]['location_string']
-      assert_equal 'US', events[0][2]['location_string2']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['location_array']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['location_array2']
-      assert_equal '[GEOIP] message => {"lat":37.419200000000004, "lon":-122.0574}', events[0][2]['peculiar_pattern']
-    end
-    def test_emit_v1_config_compatibility
-      d1 = create_driver(config_quoted_record)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      location_properties = { "country_code" => "US", "lat" => 37.419200000000004, "lon"=> -122.0574 }
-      assert_equal location_properties, events[0][2]['location_properties']
-      assert_equal '37.419200000000004,-122.0574', events[0][2]['location_string']
-      assert_equal 'US', events[0][2]['location_string2']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['location_array']
-      assert_equal [-122.0574, 37.419200000000004], events[0][2]['location_array2']
-      assert_equal '[GEOIP] message => {"lat":37.419200000000004, "lon":-122.0574}', events[0][2]['peculiar_pattern']
-    end
-    def test_emit_multiline_v1_config
-      d1 = create_driver(%[
-        backend_library   geoip2_compat
-        geoip_lookup_key  host
-        <record>
-          location_properties  {
-            "city": "${city['host']}",
-            "country_code": "${country_code['host']}",
-            "latitude": "${latitude['host']}",
-            "longitude": "${longitude['host']}"
-          }
-        </record>
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      location_properties = { "city"=>"Mountain View", "country_code"=>"US", "latitude"=>37.419200000000004, "longitude"=>-122.0574 }
-      assert_equal location_properties, events[0][2]['location_properties']
-    end
-  end
-  sub_test_case "geoip legacy" do
-    def test_emit
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  host
-        enable_key_city   geoip_city
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['geoip_city']
-      assert_equal nil, events[1][2]['geoip_city']
-    end
-    def test_emit_tag_option
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city['host']}
-        </record>
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['geoip_city']
-      assert_equal nil, events[1][2]['geoip_city']
-    end
-    def test_emit_tag_parts
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city['host']}
-        </record>
-        tag               geoip.${tag[1]}.${tag[2]}.${tag[3]}
-      ])
-      d1.run(default_tag: '0.1.2.3') do
-        d1.feed({'host' => '66.102.3.80'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.1.2.3', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['geoip_city']
-    end
-    def test_emit_with_dot_key
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  ip.origin, ip.dest
-        <record>
-          origin_country  ${country_code['ip.origin']}
-          dest_country    ${country_code['ip.dest']}
-        </record>
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'ip.origin' => '66.102.3.80', 'ip.dest' => '8.8.8.8'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'US', events[0][2]['origin_country']
-      assert_equal 'US', events[0][2]['dest_country']
-    end
-    def test_emit_nested_attr
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  host.ip
-        enable_key_city   geoip_city
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => {'ip' => '66.102.3.80'}, 'message' => 'valid ip'})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['geoip_city']
-      assert_equal nil, events[1][2]['geoip_city']
-    end
-    def test_emit_with_unknown_address
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city['host']}
-          geopoint        [${longitude['host']}, ${latitude['host']}]
-        </record>
-        skip_adding_null_record false
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        # 203.0.113.1 is a test address described in RFC5737
-        d1.feed({'host' => '203.0.113.1', 'message' => 'invalid ip'})
-        d1.feed({'host' => '0', 'message' => 'invalid ip'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal nil, events[0][2]['geoip_city']
-      assert_equal 'geoip.access', events[1][0] # tag
-      assert_equal nil, events[1][2]['geoip_city']
-    end
-    def test_emit_with_skip_unknown_address
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  host
-        <record>
-          geoip_city      ${city['host']}
-          geopoint        [${longitude['host']}, ${latitude['host']}]
-        </record>
-        skip_adding_null_record true
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        # 203.0.113.1 is a test address described in RFC5737
-        d1.feed({'host' => '203.0.113.1', 'message' => 'invalid ip'})
-        d1.feed({'host' => '0', 'message' => 'invalid ip'})
-        d1.feed({'host' => '66.102.3.80', 'message' => 'google bot'})
-      end
-      events = d1.events
-      assert_equal 3, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal nil, events[0][2]['geoip_city']
-      assert_equal nil, events[0][2]['geopoint']
-      assert_equal 'geoip.access', events[1][0] # tag
-      assert_equal nil, events[1][2]['geoip_city']
-      assert_equal nil, events[1][2]['geopoint']
-      assert_equal 'Mountain View', events[2][2]['geoip_city']
-      assert_equal [-122.05740356445312, 37.4192008972168], events[2][2]['geopoint']
-    end
-    def test_emit_multiple_key
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  from.ip, to.ip
-        enable_key_city   from_city, to_city
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['from_city']
-      assert_equal 'Tokorozawa', events[0][2]['to_city']
-      assert_equal nil, events[1][2]['from_city']
-      assert_equal nil, events[1][2]['to_city']
-    end
-    def test_emit_multiple_key_multiple_record
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  from.ip, to.ip
-        enable_key_city   from_city, to_city
-        enable_key_country_name from_country, to_country
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
-        d1.feed({'from' => {'ip' => '66.102.3.80'}})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 3, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['from_city']
-      assert_equal 'United States', events[0][2]['from_country']
-      assert_equal 'Tokorozawa', events[0][2]['to_city']
-      assert_equal 'Japan', events[0][2]['to_country']
-      assert_equal 'Mountain View', events[1][2]['from_city']
-      assert_equal 'United States', events[1][2]['from_country']
-      assert_equal nil, events[1][2]['to_city']
-      assert_equal nil, events[1][2]['to_country']
-      assert_equal nil, events[2][2]['from_city']
-      assert_equal nil, events[2][2]['from_country']
-      assert_equal nil, events[2][2]['to_city']
-      assert_equal nil, events[2][2]['to_country']
-    end
-    def test_emit_record_directive
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  from.ip
-        <record>
-          from_city       ${city['from.ip']}
-          from_country    ${country_name['from.ip']}
-          latitude        ${latitude['from.ip']}
-          longitude       ${longitude['from.ip']}
-          float_concat    ${latitude['from.ip']},${longitude['from.ip']}
-          float_array     [${longitude['from.ip']}, ${latitude['from.ip']}]
-          float_nest      { "lat" : ${latitude['from.ip']}, "lon" : ${longitude['from.ip']}}
-          string_concat   ${latitude['from.ip']},${longitude['from.ip']}
-          string_array    [${city['from.ip']}, ${country_name['from.ip']}]
-          string_nest     { "city" : ${city['from.ip']}, "country_name" : ${country_name['from.ip']}}
-          unknown_city    ${city['unknown_key']}
-          undefined       ${city['undefined']}
-          broken_array1   [${longitude['from.ip']}, ${latitude['undefined']}]
-          broken_array2   [${longitude['undefined']}, ${latitude['undefined']}]
-        </record>
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'from' => {'ip' => '66.102.3.80'}})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['from_city']
-      assert_equal 'United States', events[0][2]['from_country']
-      assert_equal 37.4192008972168, events[0][2]['latitude']
-      assert_equal -122.05740356445312, events[0][2]['longitude']
-      assert_equal '37.4192008972168,-122.05740356445312', events[0][2]['float_concat']
-      assert_equal [-122.05740356445312, 37.4192008972168], events[0][2]['float_array']
-      float_nest = {"lat" => 37.4192008972168, "lon" => -122.05740356445312 }
-      assert_equal float_nest, events[0][2]['float_nest']
-      assert_equal '37.4192008972168,-122.05740356445312', events[0][2]['string_concat']
-      assert_equal ["Mountain View", "United States"], events[0][2]['string_array']
-      string_nest = {"city" => "Mountain View", "country_name" => "United States"}
-      assert_equal string_nest, events[0][2]['string_nest']
-      assert_equal nil, events[0][2]['unknown_city']
-      assert_equal nil, events[0][2]['undefined']
-      assert_equal [-122.05740356445312, nil], events[0][2]['broken_array1']
-      assert_equal [nil, nil], events[0][2]['broken_array2']
-      assert_equal nil, events[1][2]['from_city']
-      assert_equal nil, events[1][2]['from_country']
-      assert_equal nil, events[1][2]['latitude']
-      assert_equal nil, events[1][2]['longitude']
-      assert_equal ',', events[1][2]['float_concat']
-      assert_equal [nil, nil], events[1][2]['float_array']
-      float_nest = {"lat" => nil, "lon" => nil}
-      assert_equal float_nest, events[1][2]['float_nest']
-      assert_equal ',', events[1][2]['string_concat']
-      assert_equal [nil, nil], events[1][2]['string_array']
-      string_nest = {"city" => nil, "country_name" => nil}
-      assert_equal string_nest, events[1][2]['string_nest']
-      assert_equal nil, events[1][2]['unknown_city']
-      assert_equal nil, events[1][2]['undefined']
-      assert_equal [nil, nil], events[1][2]['broken_array1']
-      assert_equal [nil, nil], events[1][2]['broken_array2']
-    end
-    def test_emit_record_directive_multiple_record
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  from.ip, to.ip
-        <record>
-          from_city       ${city['from.ip']}
-          to_city         ${city['to.ip']}
-          from_country    ${country_name['from.ip']}
-          to_country      ${country_name['to.ip']}
-          string_array    [${country_name['from.ip']}, ${country_name['to.ip']}]
-        </record>
-        tag               geoip.${tag[1]}
-      ], syntax: :v0)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
-        d1.feed({'message' => 'missing field'})
-      end
-      events = d1.events
-      assert_equal 2, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      assert_equal 'Mountain View', events[0][2]['from_city']
-      assert_equal 'United States', events[0][2]['from_country']
-      assert_equal 'Tokorozawa', events[0][2]['to_city']
-      assert_equal 'Japan', events[0][2]['to_country']
-      assert_equal ['United States','Japan'], events[0][2]['string_array']
-      assert_equal nil, events[1][2]['from_city']
-      assert_equal nil, events[1][2]['to_city']
-      assert_equal nil, events[1][2]['from_country']
-      assert_equal nil, events[1][2]['to_country']
-      assert_equal [nil, nil], events[1][2]['string_array']
-    end
-    def config_quoted_record
-      %[
-        backend_library geoip
-        geoip_lookup_key  host
-        <record>
-          location_properties  '{ "country_code" : "${country_code["host"]}", "lat": ${latitude["host"]}, "lon": ${longitude["host"]} }'
-          location_string      ${latitude['host']},${longitude['host']}
-          location_string2     ${country_code["host"]}
-          location_array       "[${longitude['host']},${latitude['host']}]"
-          location_array2      '[${longitude["host"]},${latitude["host"]}]'
-          peculiar_pattern     '[GEOIP] message => {"lat":${latitude["host"]}, "lon":${longitude["host"]}}'
-        </record>
-        tag               geoip.${tag[1]}
-      ]
-    end
-    def test_emit_quoted_record
-      d1 = create_driver(config_quoted_record)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      location_properties = { "country_code" => "US", "lat" => 37.4192008972168, "lon"=> -122.05740356445312 }
-      assert_equal location_properties, events[0][2]['location_properties']
-      assert_equal '37.4192008972168,-122.05740356445312', events[0][2]['location_string']
-      assert_equal 'US', events[0][2]['location_string2']
-      assert_equal [-122.05740356445312, 37.4192008972168], events[0][2]['location_array']
-      assert_equal [-122.05740356445312, 37.4192008972168], events[0][2]['location_array2']
-      assert_equal '[GEOIP] message => {"lat":37.4192008972168, "lon":-122.05740356445312}', events[0][2]['peculiar_pattern']
-    end
-    def test_emit_v1_config_compatibility
-      d1 = create_driver(config_quoted_record)
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      location_properties = { "country_code" => "US", "lat" => 37.4192008972168, "lon"=> -122.05740356445312 }
-      assert_equal location_properties, events[0][2]['location_properties']
-      assert_equal '37.4192008972168,-122.05740356445312', events[0][2]['location_string']
-      assert_equal 'US', events[0][2]['location_string2']
-      assert_equal [-122.05740356445312, 37.4192008972168], events[0][2]['location_array']
-      assert_equal [-122.05740356445312, 37.4192008972168], events[0][2]['location_array2']
-      assert_equal '[GEOIP] message => {"lat":37.4192008972168, "lon":-122.05740356445312}', events[0][2]['peculiar_pattern']
-    end
-    def test_emit_multiline_v1_config
-      d1 = create_driver(%[
-        backend_library geoip
-        geoip_lookup_key  host
-        <record>
-          location_properties  {
-            "city": "${city['host']}",
-            "country_code": "${country_code['host']}",
-            "latitude": "${latitude['host']}",
-            "longitude": "${longitude['host']}"
-          }
-        </record>
-        tag               geoip.${tag[1]}
-      ])
-      d1.run(default_tag: 'input.access') do
-        d1.feed({'host' => '66.102.3.80', 'message' => 'valid ip'})
-      end
-      events = d1.events
-      assert_equal 1, events.length
-      assert_equal 'geoip.access', events[0][0] # tag
-      location_properties = { "city"=>"Mountain View", "country_code"=>"US", "latitude"=>37.4192008972168, "longitude"=>-122.05740356445312 }
-      assert_equal location_properties, events[0][2]['location_properties']
-    end
-  end
-end