fluent-plugin-geoip-kk 1.0.2 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3343f0a6464f46969141b4c6dbc731bf58ff1bddabeecd0f55bfad2a4c21b842
-  data.tar.gz: 7c90087650a115cd023d3cde331d7504ee0540432747554e2150abd6d0ea780d
+  metadata.gz: ca6935a0106345ce2856c8f459b8b51b479f2058c07d06a054e65098b656ce8d
+  data.tar.gz: aa54bc540919b711a437803a1ee68c57d1457d315dc51448d3acaabf24197c8f
 SHA512:
-  metadata.gz: dfd08a491d65964d1ed9ec4927ed1041f07f5a376b91b36cabf4a18c430854a7e1241fb3cbc73c65d9eb1d912f9f509659939dae5223cc4e0a63ca9cfafa6855
-  data.tar.gz: 4f534578358e07d02a193f9019c143304e8c3ef4997a22bf14f52ce8ec384884b804a12d9130ab84c281c4d34ec873dc270f63c216a5a6c6c8246613913f36df
+  metadata.gz: be6b1caf1cdb676909b21b19cd5827a232163844f8610f7f4490c40f442e2076ef9e4b40d3ac953d6f734cb88654223265eccf9a16def980342280599c1d4f17
+  data.tar.gz: 1503fab319f62797e5d1fede06acbdbb932b0003ddd6722628f259f391d0bc428d31d1662a5deb6d56c8720eb77df25c240803f3906891069633a427aaaf4760

data/README.md

@@ -9,9 +9,17 @@
 
 | fluent-plugin-geoip-kk | fluentd    | ruby   |
 |----------------------------|------------|--------|
-| >= 1.0.1                   | >= v0.14.0 | >= 2.1 |
+| >= 1.0.5                   | >= v0.14.0 | >= 2.1 |
 | < 1.0.0                    | >= v0.12.0 | >= 1.9 |
 
+## Features
+
+- Automatic database handling (compressed/uncompressed)
+- Memory-optimized database loading
+- LRU caching for high-performance lookups
+- Support for both legacy GeoIP and GeoIP2 databases
+- Private IP address filtering
+- Flexible output formatting (nested/flattened)
 
 ## Installation
 
@@ -23,78 +31,142 @@ $ gem install fluent-plugin-geoip-kk
 $ sudo td-agent-gem install fluent-plugin-geoip-kk
 ```
 
+## Configuration Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| key_name | string | client_ip | Field name that contains the IP address |
+| out_key | string | geo | Output field name to store GeoIP data |
+| database_path | string | auto-detect | Path to the GeoIP database file (supports .mmdb and .mmdb.gz) |
+| flatten | bool | false | Flatten the GeoIP data structure |
+| cache_size | integer | 8192 | Size of the LRU cache |
+| cache_ttl | integer | 3600 | TTL for cached items in seconds |
+| skip_private_ip | bool | true | Skip adding GeoIP data for private IP addresses |
+| memory_cache | bool | true | Keep database in memory for better performance |
 
-## Usage
+## Usage Examples
 
-### Example 1:
+### Basic Configuration
 
 ```xml
 <filter access.nginx.**>
   @type geoip
-  # key_name client_ip
-  # database_path /data/geoip/GeoLite2-City.mmdb
-  # out_key geo
+  key_name client_ip
+  out_key geo
 </filter>
 ```
 
-Assuming following inputs are coming:
+### Advanced Configuration
 
-```json
-access.nginx: {
-  "client_ip":"93.184.216.34",
-  "scheme":"http", "method":"GET", "host":"example.com",
-  "path":"/", "query":"-", "req_bytes":200, "referer":"-",
-  "status":200, "res_bytes":800, "res_body_bytes":600, "taken_time":0.001, "user_agent":"Mozilla/5.0"
-}
+```xml
+<filter access.nginx.**>
+  @type geoip
+
+  # IP address field configuration
+  key_name client_ip
+  out_key geo
+
+  # Database configuration
+  database_path /path/to/your/GeoLite2-City.mmdb.gz  # Optional: supports both .mmdb and .mmdb.gz
+
+  # Performance optimization
+  memory_cache true     # Keep database in memory (recommended)
+  cache_size 10000     # LRU cache size
+  cache_ttl 3600      # Cache TTL in seconds
+
+  # Output configuration
+  flatten false       # Keep nested structure
+
+  # IP processing configuration
+  skip_private_ip true  # Skip private IP addresses
+</filter>
 ```
 
-then output bocomes as belows:
+### Output Examples
 
+#### Default Structure (flatten: false)
 ```json
-access.nginx: {
-  "client_ip":"93.184.216.34",
-  "scheme":"http", "method":"GET", "host":"example.com",
-  "path":"/", "query":"-", "req_bytes":200, "referer":"-",
-  "status":200, "res_bytes":800, "res_body_bytes":600, "taken_time":0.001, "user_agent":"Mozilla/5.0",
+{
+  "client_ip": "93.184.216.34",
   "geo": {
-    "coordinates": [-70.8228, 42.150800000000004],
-    "country_code": "US",
-    "city": "Norwell",
-    "region_code": "MA",
+    "coordinates": {
+      "latitude": 42.150800000000004,
+      "longitude": -70.8228,
+      "accuracy_radius": 100
+    },
+    "country": {
+      "code": "US",
+      "name": "United States"
+    },
+    "city": {
+      "name": "Norwell",
+      "confidence": 90
+    },
+    "region": {
+      "code": "MA",
+      "name": "Massachusetts"
+    },
+    "postal": {
+      "code": "02061",
+      "confidence": 95
+    },
+    "timezone": "America/New_York"
   }
 }
 ```
 
+#### Flattened Structure (flatten: true)
+```json
+{
+  "client_ip": "93.184.216.34",
+  "geo_coordinates_latitude": 42.150800000000004,
+  "geo_coordinates_longitude": -70.8228,
+  "geo_coordinates_accuracy_radius": 100,
+  "geo_country_code": "US",
+  "geo_country_name": "United States",
+  "geo_city_name": "Norwell",
+  "geo_city_confidence": 90,
+  "geo_region_code": "MA",
+  "geo_region_name": "Massachusetts",
+  "geo_postal_code": "02061",
+  "geo_postal_confidence": 95,
+  "geo_timezone": "America/New_York"
+}
+```
 
-## Parameters
-- key_name *field_key*
-
-    Target key name. default client_ip.
-
-- out_key *string*
+## Performance Optimization
 
-    Output prefix key name. default geo.
+### Memory Usage vs Performance
 
-- database_path *file_path*
+The plugin offers two modes for database handling:
 
-    Database file(GeoIPCity.dat) path.
-    Get from [MaxMind](http://dev.maxmind.com/geoip/legacy/geolite/)
+1. Memory Mode (Default, Recommended)
+   - Loads entire database into memory
+   - Fastest lookup performance
+   - Higher memory usage (~56MB for GeoLite2-City)
+   - Best for production environments
 
-- flatten *bool*
-    join hashed data by '_'. default false.
+2. File Mode
+   - Keeps database on disk
+   - Lower memory usage
+   - Slightly slower lookups due to disk I/O
+   - Suitable for memory-constrained environments
 
+### Caching Strategy
 
-## VS.
-[fluent-plugin-geoip](https://github.com/y-ken/fluent-plugin-geoip)
-Fluentd output plugin to geolocate with geoip.
-It is able to customize fields with placeholder.
+- LRU (Least Recently Used) cache with TTL
+- Default cache size: 8192 entries
+- Default TTL: 3600 seconds (1 hour)
+- Adjust based on your traffic patterns:
+  - High unique IPs: Increase cache_size
+  - Stable IP patterns: Increase cache_ttl
 
-* Easy to install.
-    * Not require to install Development Tools and geoip-dev library.
-    * ( fluent-plugin-geoip use geoip-c gem but our plugin use geoip. It's conflict. )
-* 5-10 times faster by the LRU cache.
-    * See [benchmark](test/bench_geoip_filter.rb).
+### Database Compression
 
+- Database is distributed in compressed format (.mmdb.gz)
+- Automatic handling of compressed/uncompressed files
+- ~52% size reduction (56MB → 27MB)
+- No performance impact when using memory_cache
 
 ## Development
 
@@ -127,12 +199,6 @@ This gem uses GitHub Actions for automated publishing. To publish a new version:
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
 
-
-## Copyright
-
-Copyright (c) 2015 Yuri Umezaki
-
-
 ## License
 
 [Apache License, Version 2.0.](http://www.apache.org/licenses/LICENSE-2.0)

data/Rakefile

@@ -12,6 +12,7 @@ Rake::TestTask.new(:test) do |test|
 end
 
 task :push do
+  system 'rubocop -A'
   system 'git add .'
   system "git commit -m 'Update #{Time.now}.'"
   system 'git pull'

data/fluent-plugin-geoip-kk.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'fluent-plugin-geoip-kk'
-  spec.version       = '1.0.2'
+  spec.version       = '1.0.5'
   spec.authors       = ['kevin197011']
   spec.email         = ['kevin197011@outlook.com']
   spec.homepage      = 'https://github.com/kevin197011/fluent-plugin-geoip-kk'
@@ -13,11 +13,27 @@ Gem::Specification.new do |spec|
   spec.description   = 'A Fluentd filter plugin that adds GeoIP information to records. Supports both legacy GeoIP and GeoIP2 databases, with LRU caching for improved performance.'
   spec.license       = 'Apache-2.0'
 
-  spec.files         = `git ls-files -z`.split("\x0")
+  # Include all git tracked files and vendor/data directory
+  spec.files = Dir[
+    'lib/**/*',
+    'vendor/**/*.mmdb.gz',
+    'Gemfile',
+    'LICENSE',
+    'README.md',
+    'Rakefile',
+    '*.gemspec'
+  ]
+
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
+  # Ensure vendor/data directory is included
+  spec.metadata = {
+    'data_dir' => 'vendor/data',
+    'database_file' => 'GeoLite2-City.mmdb.gz'
+  }
+
   spec.add_runtime_dependency 'fluentd', ['>= 0.14.0', '< 2']
   spec.add_runtime_dependency 'geoip', '~> 0.1', '>= 0.1.22'
   spec.add_runtime_dependency 'lru_redux', '~> 1.0', '>= 1.0.0'

data/lib/fluent/plugin/filter_geoip.rb

@@ -4,6 +4,8 @@ require 'maxminddb'
 require 'lru_redux'
 require 'fluent/plugin/filter'
 require 'ipaddr'
+require 'zlib'
+require 'stringio'
 
 module Fluent
   module Plugin
@@ -15,9 +17,10 @@ module Fluent
       # Default cache size (number of IP addresses to cache)
       DEFAULT_CACHE_SIZE = 8192
       DEFAULT_CACHE_TTL = 3600 # 1 hour in seconds
+      DEFAULT_DB_FILENAME = 'GeoLite2-City.mmdb'
 
       desc 'Path to the GeoIP database file'
-      config_param :database_path, :string, default: "#{File.dirname(__FILE__)}/../../../data/GeoLite2-City.mmdb"
+      config_param :database_path, :string, default: nil
 
       desc 'Field name that contains the IP address'
       config_param :key_name, :string, default: 'client_ip'
@@ -37,22 +40,37 @@ module Fluent
       desc 'Skip adding GeoIP data for private IP addresses'
       config_param :skip_private_ip, :bool, default: true
 
+      desc 'Keep database in memory'
+      config_param :memory_cache, :bool, default: true
+
       def initialize
         super
         @geoip = nil
         @ip_accessor = nil
+        @database_data = nil
       end
 
       def configure(conf)
         super
 
-        unless File.exist?(@database_path)
-          raise Fluent::ConfigError, "GeoIP database file '#{@database_path}' does not exist"
-        end
+        start_time = Time.now
+        @database_path = resolve_database_path
 
         # Initialize MaxMindDB
         begin
-          @geoip = MaxMindDB.new(@database_path)
+          if @memory_cache
+            @database_data = load_database(@database_path)
+            @geoip = MaxMindDB.new(StringIO.new(@database_data))
+          else
+            @geoip = MaxMindDB.new(decompress_if_needed(@database_path))
+          end
+
+          load_time = Time.now - start_time
+          log.info 'Loaded GeoIP database',
+                   database: @database_path,
+                   size: format_size(@database_data ? @database_data.size : File.size(@database_path)),
+                   compressed_size: format_size(File.size(@database_path)),
+                   load_time: format_time(load_time)
         rescue StandardError => e
           raise Fluent::ConfigError, "Failed to load GeoIP database: #{e.message}"
         end
@@ -63,7 +81,16 @@ module Fluent
         # Initialize cache with TTL support
         @geoip_cache = LruRedux::TTL::Cache.new(@cache_size, @cache_ttl)
 
-        log.info "Initialized GeoIP filter", database: @database_path, cache_size: @cache_size, cache_ttl: @cache_ttl
+        log.info 'Initialized GeoIP filter',
+                 database: @database_path,
+                 cache_size: @cache_size,
+                 cache_ttl: @cache_ttl,
+                 memory_cache: @memory_cache
+      end
+
+      def shutdown
+        super
+        @temp_db.unlink if @temp_db && File.exist?(@temp_db.path)
       end
 
       def filter(tag, time, record)
@@ -74,7 +101,7 @@ module Fluent
           ip = IPAddr.new(ip_addr)
           return record if @skip_private_ip && ip.private?
         rescue IPAddr::InvalidAddressError => e
-          log.debug "Invalid IP address", ip: ip_addr, error: e.message
+          log.debug 'Invalid IP address', ip: ip_addr, error: e.message
           return record
         end
 
@@ -89,71 +116,174 @@ module Fluent
 
         record
       rescue StandardError => e
-        log.error "Failed to process GeoIP lookup", error_class: e.class, error: e.message, tag: tag, time: time
+        log.error 'Failed to process GeoIP lookup', error_class: e.class, error: e.message, tag: tag, time: time
         record
       end
 
       private
 
+      def resolve_database_path
+        return database_path if database_path && !database_path.empty?
+
+        # Search paths in order of preference
+        search_paths = [
+          # 1. Current directory
+          File.join(Dir.pwd, 'vendor/data', DEFAULT_DB_FILENAME),
+          File.join(Dir.pwd, 'vendor/data', "#{DEFAULT_DB_FILENAME}.gz"),
+          # 2. Gem vendor directory
+          File.expand_path("../../../vendor/data/#{DEFAULT_DB_FILENAME}", __FILE__),
+          File.expand_path("../../../vendor/data/#{DEFAULT_DB_FILENAME}.gz", __FILE__),
+          # 3. System-wide locations
+          '/usr/share/GeoIP/GeoLite2-City.mmdb',
+          '/usr/local/share/GeoIP/GeoLite2-City.mmdb'
+        ]
+
+        # Find first existing database file
+        found_path = search_paths.find { |path| File.exist?(path) }
+
+        unless found_path
+          available_paths = search_paths.join("\n  ")
+          raise Fluent::ConfigError, "Could not find GeoIP database file. Searched in:\n  #{available_paths}"
+        end
+
+        log.info 'Found GeoIP database', path: found_path
+        found_path
+      end
+
+      def load_database(path)
+        if path.end_with?('.gz')
+          Zlib::GzipReader.open(path, &:read)
+        else
+          File.binread(path)
+        end
+      end
+
+      def decompress_if_needed(path)
+        return path unless path.end_with?('.gz')
+
+        decompressed_path = path.chomp('.gz')
+        unless File.exist?(decompressed_path)
+          File.open(decompressed_path, 'wb') do |file|
+            Zlib::GzipReader.open(path) do |gz|
+              file.write(gz.read)
+            end
+          end
+        end
+        decompressed_path
+      end
+
+      def format_size(bytes)
+        units = %w[B KB MB GB]
+        size = bytes.to_f
+        unit_index = 0
+
+        while size > 1024 && unit_index < units.length - 1
+          size /= 1024
+          unit_index += 1
+        end
+
+        format('%.2f %s', size, units[unit_index])
+      end
+
+      def format_time(seconds)
+        if seconds < 1
+          format('%.2f ms', seconds * 1000)
+        else
+          format('%.2f s', seconds)
+        end
+      end
+
       def get_geoip(ip_addr)
         geo_ip = @geoip.lookup(ip_addr)
         return {} if geo_ip.nil?
 
-        {
-          'coordinates' => get_coordinates(geo_ip),
-          'country' => get_country_info(geo_ip),
-          'city' => get_city_info(geo_ip),
-          'region' => get_region_info(geo_ip),
-          'postal' => get_postal_info(geo_ip),
-          'timezone' => geo_ip.location&.time_zone
-        }.compact
+        result = {}
+
+        if (coordinates = get_coordinates(geo_ip))
+          result['coordinates'] = coordinates
+        end
+
+        if (country = get_country_info(geo_ip))
+          result['country'] = country
+        end
+
+        if (city = get_city_info(geo_ip))
+          result['city'] = city
+        end
+
+        if (region = get_region_info(geo_ip))
+          result['region'] = region
+        end
+
+        if (postal = get_postal_info(geo_ip))
+          result['postal'] = postal
+        end
+
+        result['timezone'] = geo_ip.location.time_zone if geo_ip.location && geo_ip.location.time_zone
+
+        result
       end
 
       def get_coordinates(geo_ip)
         return nil unless geo_ip.location
 
-        {
-          'latitude' => geo_ip.location.latitude,
-          'longitude' => geo_ip.location.longitude,
-          'accuracy_radius' => geo_ip.location.accuracy_radius
-        }.compact
+        result = {}
+        location = geo_ip.location
+
+        result['latitude'] = location.latitude if location.latitude
+        result['longitude'] = location.longitude if location.longitude
+        result['accuracy_radius'] = location.accuracy_radius if location.accuracy_radius
+
+        result.empty? ? nil : result
       end
 
       def get_country_info(geo_ip)
         return nil unless geo_ip.country
 
-        {
-          'code' => geo_ip.country.iso_code,
-          'name' => geo_ip.country.name
-        }.compact
+        result = {}
+        country = geo_ip.country
+
+        result['code'] = country.iso_code if country.iso_code
+        result['name'] = country.name if country.name
+
+        result.empty? ? nil : result
       end
 
       def get_city_info(geo_ip)
         return nil unless geo_ip.city
 
-        {
-          'name' => geo_ip.city.name,
-          'confidence' => geo_ip.city.confidence
-        }.compact
+        result = {}
+        city = geo_ip.city
+
+        result['name'] = city.name if city.name
+        result['confidence'] = city.confidence if city.confidence
+
+        result.empty? ? nil : result
       end
 
       def get_region_info(geo_ip)
-        return nil unless geo_ip.subdivisions&.any?
+        return nil unless geo_ip.subdivisions && !geo_ip.subdivisions.empty?
 
         subdivision = geo_ip.subdivisions.first
-        {
-          'code' => subdivision.iso_code,
-          'name' => subdivision.name
-        }.compact
+        return nil unless subdivision
+
+        result = {}
+        result['code'] = subdivision.iso_code if subdivision.iso_code
+        result['name'] = subdivision.name if subdivision.name
+
+        result.empty? ? nil : result
       end
 
       def get_postal_info(geo_ip)
         return nil unless geo_ip.postal
 
-        {
-          'code' => geo_ip.postal.code,
-          'confidence' => geo_ip.postal.confidence
-        }.compact
+        result = {}
+        postal = geo_ip.postal
+
+        result['code'] = postal.code if postal.code
+        result['confidence'] = postal.confidence if postal.confidence
+
+        result.empty? ? nil : result
       end
 
       def hash_flatten(hash, keys = [])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-geoip-kk
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.5
 platform: ruby
 authors:
 - kevin197011
@@ -140,23 +140,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/gem-push.yml"
-- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- data/GeoLite2-City.mmdb
 - fluent-plugin-geoip-kk.gemspec
 - lib/fluent/plugin/filter_geoip.rb
-- push.rb
-- test.rb
-- test/bench_geoip_filter.rb
-- test/helper.rb
+- vendor/data/GeoLite2-City.mmdb.gz
 homepage: https://github.com/kevin197011/fluent-plugin-geoip-kk
 licenses:
 - Apache-2.0
-metadata: {}
+metadata:
+  data_dir: vendor/data
+  database_file: GeoLite2-City.mmdb.gz
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -176,6 +172,4 @@ rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Fluentd filter plugin to add geoip
-test_files:
-- test/bench_geoip_filter.rb
-- test/helper.rb
+test_files: []

data/.github/workflows/gem-push.yml

@@ -1,34 +0,0 @@
-name: Ruby Gem
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-    name: Build + Publish
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: '3.2'   # 你可以指定 3.1、3.2、3.3 等
-
-      - name: Publish to RubyGems
-        run: |
-          mkdir -p $HOME/.gem
-          touch $HOME/.gem/credentials
-          chmod 0600 $HOME/.gem/credentials
-          printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-          gem build *.gemspec
-          gem push *.gem
-        env:
-          GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_API_KEY}}"

data/.gitignore

@@ -1,22 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-*.bundle
-*.so
-*.o
-*.a
-mkmf.log

data/push.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-system 'rake'

data/test/bench_geoip_filter.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require 'fluent/plugin/filter_geoip'
-
-# setup
-Fluent::Test.setup
-config = %(
-  @type geoip
-  out_key geo
-)
-time = Time.now.to_i
-tag = 'foo.bar'
-driver = Fluent::Test::FilterTestDriver.new(Fluent::GeoipFilter, tag).configure(config, true)
-
-# bench
-require 'benchmark'
-require 'ipaddr'
-n = 100_000
-Benchmark.bm(7) do |x|
-  # 8192 random IP
-  x.report do
-    driver.run do
-      n.times do
-        driver.emit({ 'client_ip' => IPAddr.new(rand(2**13) * 2**19, Socket::AF_INET).to_s }, time)
-      end
-    end
-  end
-end
-
-# Without LRU cache
-#              user     system      total        real
-#         11.410000   2.730000  14.140000 ( 15.431248)
-# With LRU cache(8192) & random  1024 IP
-#              user     system      total        real
-#          1.250000   0.070000   1.320000 (  1.322339)
-# With LRU cache(8192) & random  8192 IP
-#              user     system      total        real
-#          1.890000   0.210000   2.100000 (  2.102445)
-# With LRU cache(8192) & random 16384 IP
-#              user     system      total        real
-#          8.450000   2.070000  10.520000 ( 12.170379)
-# With LRU cache(8192) & random 65536 IP
-#              user     system      total        real
-#         11.890000   2.820000  14.710000 ( 16.051674)
-
-# fluent-plugin-geoip
-# (https://github.com/y-ken/fluent-plugin-geoip)
-#              user     system      total        real
-#         11.540000   0.270000  11.810000 ( 12.685000)

data/test/helper.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  warn e.message
-  warn 'Run `bundle install` to install missing gems'
-  exit e.status_code
-end
-require 'test/unit'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'fluent/test'
-unless ENV.key?('VERBOSE')
-  nulllogger = Object.new
-  nulllogger.instance_eval do |_obj|
-    def method_missing(method, *args)
-      # pass
-    end
-  end
-  $log = nulllogger
-end
-require 'fluent/test/helpers'
-require 'fluent/test/driver/filter'
-require 'fluent/plugin/filter_geoip'
-
-module Test
-  module Unit
-    class TestCase
-      include Fluent::Test::Helpers
-    end
-  end
-end

data/test.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'maxminddb'
-
-db = MaxMindDB.new('data/GeoLite2-City.mmdb')
-
-ip = '128.101.101.101'
-
-begin
-  result = db.lookup(ip)
-
-  puts "IP: #{ip}"
-  puts "Country: #{result.country.name}"
-  puts "City: #{result.city.name}" if result.city.name
-  puts "Latitude: #{result.location.latitude}" if result.location.latitude
-  puts "Longitude: #{result.location.longitude}" if result.location.longitude
-  puts result.inspect
-rescue MaxMindDB::AddressNotFoundError
-  puts 'IP address not found in the database.'
-end