fluent-plugin-geoip 1.0.0 → 1.3.2

data/utils/dump.rb

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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