fluent-plugin-groonga 1.0.5 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2bddd43990cc83433776467a275c7c3ac0e16407
-  data.tar.gz: 0259005297bc33bd6476eb34d5bdae3cbbcfd978
+  metadata.gz: fc471bf3943996d9224a54431bf81a5323c53dcd
+  data.tar.gz: 3c37826e7793bbcab4d8009c6d0555aa74577858
 SHA512:
-  metadata.gz: 1eddbfd3cdcc690f38e5544d31c9ff29a9df51b3758c3bcdc3de096636b0bb2aac8a24312d476be0b7a6780fca415d219e0547b3f57b1e46a533dbaaa79903a6
-  data.tar.gz: 15a9fcfe04e8d18bc1c6190abbe718c8939bd6cdf6dcc027302277e504f05b71bb8db0ab39d092d00c4da3404dde014dd2ae9982f471e19699368193369ccfe0
+  metadata.gz: d1dc9a521003ddc42ccc0ff98e88468931b4d9400e5d7cb5e592a836d1be655a858a396a9275c1058a8c221041854c3d5e69e481781fdc475e0911d1595301d3
+  data.tar.gz: 63e6a01cafd4bcb3e104ec80bcd53a48a4d375f29f95a292b4f214e360c287a846d41f120dd5e3b9ed52ef587f60a5cd7283dad7c03aa14f07b9d80f2adf6807

data/Gemfile

@@ -1,6 +1,6 @@
 # -*- mode: ruby; coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2014  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -15,6 +15,6 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-source :rubygems
+source "https://rubygems.org/"
 
 gemspec

data/README.md

@@ -42,7 +42,7 @@ into Groonga:
 
     <match log.**>
       type groonga
-      table logs
+      store_table logs
 
       protocol http
       host 127.0.0.1
@@ -88,13 +88,13 @@ define schema in Groonga before running Fluentd. You just run Groonga.
 
 There is one required parameter:
 
-  * `table`: It specifies table name for storing logs.
+  * `store_table`: It specifies table name for storing logs.
 
 Here is a minimum configuration:
 
     <match log.**>
       type groonga
-      table logs
+      store_table logs
     </match>
 
 The configuration stores logs into `logs` table in Groonga that runs
@@ -115,7 +115,7 @@ Here is a configuration that specifies optional parameters explicitly:
 
     <match log.**>
       type groonga
-      table logs
+      store_table logs
 
       protocol http
       host 127.0.0.1

data/doc/text/news.md

@@ -2,6 +2,18 @@
 
 # News
 
+## 1.0.6: 2014-11-05
+
+### Improvements
+
+* out: Renamed `table` parameter name to `store_table`.
+  `table` parameter is still usable for backward compatibility.
+* out: Supported table definition by `<table>` configuration.
+  See sample/store-apache.conf for details.
+* out: Supported specifying column type and creating indexes for auto
+  created columns by `<mapping>` configuration.
+  See sample/store-apache.conf for details.
+
 ## 1.0.5: 2014-10-21
 
 ### Improvements

data/fluent-plugin-groonga.gemspec

@@ -17,7 +17,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "fluent-plugin-groonga"
-  spec.version = "1.0.5"
+  spec.version = "1.0.6"
   spec.authors = ["Kouhei Sutou"]
   spec.email = ["kou@clear-code.com"]
   spec.summary = "Fluentd plugin to store data into Groonga and implement Groonga replication system."
@@ -35,7 +35,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency("fluentd")
-  spec.add_runtime_dependency("groonga-client")
+  spec.add_runtime_dependency("groonga-client", ">= 0.1.0")
   spec.add_runtime_dependency("groonga-command-parser")
 
   spec.add_development_dependency("rake")

data/lib/fluent/plugin/out_groonga.rb

@@ -37,20 +37,65 @@ module Fluent
         raise ConfigError, "must be http, gqtp or command: <#{value}>"
       end
     end
-    config_param :table, :string, :default => nil
+
+    # alias is just for backward compatibility
+    config_param :store_table, :string, :default => nil, :alias => :table
+
+    config_section :table,
+                   :param_name => "tables",
+                   :required => false,
+                   :multi => true do
+      config_param :name, :string
+      config_param :flags, :string, :default => nil
+      config_param :key_type, :string, :default => nil
+      config_param :default_tokenizer, :string, :default => nil
+      config_param :token_filters, :string, :default => nil
+      config_param :normalizer, :string, :default => nil
+      config_section :index,
+                     :param_name => "indexes",
+                     :required => false,
+                     :multi => true do
+        config_param :name, :string
+        config_param :source_table, :string
+        config_param :source_columns, :string
+      end
+    end
+
+    config_section :mapping,
+                   :param_name => "mappings",
+                   :required => false,
+                   :multi => true do
+      config_param :name, :string
+      config_param :type, :string, :default => nil
+      config_section :index,
+                     :param_name => "indexes",
+                     :required => false,
+                     :multi => true do
+        config_param :table, :string
+        config_param :name, :string
+        config_param :flags, :string, :default => nil
+      end
+    end
 
     def configure(conf)
       super
       @client = create_client(@protocol)
       @client.configure(conf)
 
-      @emitter = Emitter.new(@client, @table)
+      @schema = Schema.new(@client, @store_table, @mappings)
+      @emitter = Emitter.new(@client, @store_table, @schema)
+
+      @tables = @tables.collect do |table|
+        TableDefinition.new(table)
+      end
     end
 
     def start
       super
       @client.start
       @emitter.start
+      tables_creator = TablesCreator.new(@client, @tables)
+      tables_creator.create
     end
 
     def shutdown
@@ -77,18 +122,171 @@ module Fluent
       end
     end
 
+    class TableDefinition
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def name
+        @raw[:name]
+      end
+
+      def flags
+        parse_flags(@raw[:flags] || "TABLE_NO_KEY")
+      end
+
+      def key_type
+        @raw[:key_type]
+      end
+
+      def default_tokenizer
+        @raw[:default_tokenizer]
+      end
+
+      def token_filters
+        parse_items(@raw[:token_filters] || "")
+      end
+
+      def normalizer
+        @raw[:normalizer]
+      end
+
+      def indexes
+        (@raw[:indexes] || []).collect do |raw|
+          IndexDefinition.new(self, raw)
+        end
+      end
+
+      def use_n_gram_tokenizer?
+        /\AToken(?:Uni|Bi|Tri)gram/ === default_tokenizer.to_s
+      end
+
+      def have_difference?(table)
+        return true if table.name != name
+
+        table_flags = (parse_flags(table.flags) - ["PERSISTENT"])
+        return true if table_flags.sort != flags.sort
+
+        return true if table.domain != key_type
+
+        return true if table.default_tokenizer != default_tokenizer
+
+        # TODO
+        # return true if table.token_filters.sort != token_filters.sort
+
+        return true if table.normalizer != normalizer
+
+        false
+      end
+
+      def to_create_arguments
+        arguments = {
+          "name" => name,
+          "flags" => flags.join("|"),
+          "key_type" => key_type,
+          "default_tokenizer" => default_tokenizer,
+          # TODO
+          # "token_filters" => token_filters.join("|"),
+          "normalizer" => normalizer,
+        }
+        arguments.keys.each do |key|
+          value = arguments[key]
+          arguments.delete(key) if value.nil? or value.empty?
+        end
+        arguments
+      end
+
+      private
+      def parse_flags(flags)
+        if flags.is_a?(Array)
+          flags
+        else
+          flags.strip.split(/\s*\|\s*/)
+        end
+      end
+
+      def parse_items(items)
+        if items.is_a?(Array)
+          items
+        else
+          items.strip.split(/\s*,\s*/)
+        end
+      end
+
+      class IndexDefinition
+        def initialize(table, raw)
+          @table = table
+          @raw = raw
+        end
+
+        def name
+          @raw[:name]
+        end
+
+        def source_table
+          @raw[:source_table]
+        end
+
+        def source_columns
+          @raw[:source_columns]
+        end
+
+        def flags
+          _flags = ["COLUMN_INDEX"]
+          _flags << "WITH_POSITION" if @table.use_n_gram_tokenizer?
+          _flags << "WITH_SECTION" if source_columns.size >= 2
+          _flags
+        end
+
+        def to_create_arguments
+          {
+            "table"  => @table.name,
+            "name"   => name,
+            "flags"  => flags.join,
+            "type"   => source_table,
+            "source" => source_columns,
+          }
+        end
+      end
+    end
+
+    class TablesCreator
+      def initialize(client, definitions)
+        @client = client
+        @definitions = definitions
+      end
+
+      def create
+        return if @definitions.empty?
+
+        table_list = @client.execute("table_list")
+        @definitions.each do |definition|
+          existing_table = table_list.find do |table|
+            table.name == definition.name
+          end
+          if existing_table
+            next unless definition.have_difference?(existing_table)
+            # TODO: Is it OK?
+            @client.execute("table_remove", "name" => definition.name)
+          end
+
+          @client.execute("table_create", definition.to_create_arguments)
+          definition.indexes.each do |index|
+            @client.execute("column_create", index.to_create_arguments)
+          end
+        end
+      end
+    end
+
     class Schema
-      def initialize(client, table_name)
+      def initialize(client, table_name, mappings)
         @client = client
         @table_name = table_name
+        @mappings = mappings
         @table = nil
         @columns = nil
       end
 
-      def populate
-        # TODO
-      end
-
       def update(records)
         ensure_table
         ensure_columns
@@ -120,7 +318,6 @@ module Fluent
         if target_table
           @table = Table.new(@table_name, target_table.domain)
         else
-          # TODO: Check response
           @client.execute("table_create",
                           "name"  => @table_name,
                           "flags" => "TABLE_NO_KEY")
@@ -142,20 +339,37 @@ module Fluent
       end
 
       def create_column(name, sample_values)
+        mapping = @mappings.find do |mapping|
+          mapping.name == name
+        end
+        if mapping
+          value_type = mapping[:type]
+        end
         guesser = TypeGuesser.new(sample_values)
-        value_type = guesser.guess
+        value_type ||= guesser.guess
         vector_p = guesser.vector?
         if vector_p
           flags = "COLUMN_VECTOR"
         else
           flags = "COLUMN_SCALAR"
         end
-        # TODO: Check response
         @client.execute("column_create",
                         "table" => @table_name,
                         "name" => name,
                         "flags" => flags,
                         "type" => value_type)
+        if mapping
+          mapping.indexes.each do |index|
+            index_flags = ["COLUMN_INDEX", index[:flags]].compact
+            @client.execute("column_create",
+                            "table" => index[:table],
+                            "name" => index[:table],
+                            "flags" => index_flags.join("|"),
+                            "type" => @table_name,
+                            "source" => name)
+          end
+        end
+
         Column.new(name, value_type, vector_p)
       end
 
@@ -170,8 +384,10 @@ module Fluent
           return "Int64"         if int64_values?
           return "Float"         if float_values?
           return "WGS84GeoPoint" if geo_point_values?
+          return "LongText"      if long_text_values?
+          return "Text"          if text_values?
 
-          "Text"
+          "ShortText"
         end
 
         def vector?
@@ -254,6 +470,22 @@ module Fluent
               /\A-?\d+(?:\.\d+)[,x]-?\d+(?:\.\d+)\z/ =~ sample_value
           end
         end
+
+        MAX_SHORT_TEXT_SIZE = 2 ** 12
+        MAX_TEXT_SIZE       = 2 ** 16
+        def text_values?
+          @sample_values.any? do |sample_value|
+            sample_value.is_a?(String) and
+              sample_value.bytesize > MAX_SHORT_TEXT_SIZE
+          end
+        end
+
+        def long_text_values?
+          @sample_values.any? do |sample_value|
+            sample_value.is_a?(String) and
+              sample_value.bytesize > MAX_TEXT_SIZE
+          end
+        end
       end
 
       class Table
@@ -273,14 +505,13 @@ module Fluent
     end
 
     class Emitter
-      def initialize(client, table)
+      def initialize(client, table, schema)
         @client = client
         @table = table
-        @schema = nil
+        @schema = schema
       end
 
       def start
-        @schema = Schema.new(@client, @table)
       end
 
       def shutdown
@@ -352,7 +583,13 @@ module Fluent
                                         :host     => @host,
                                         :port     => @port,
                                         :backend  => :synchronous)
-        @client.execute(command)
+        response = @client.execute(command)
+        unless response.success?
+          $log.error("[output][groonga][error]",
+                     :status_code => response.status_code,
+                     :message => response.message)
+        end
+        response
       end
     end
 
@@ -453,14 +690,14 @@ module Fluent
         end
 
         unless output_message.empty?
-          Engine.log.debug("[output][groonga][output]",
-                           :context => context,
-                           :message => output_message)
+          $log.debug("[output][groonga][output]",
+                     :context => context,
+                     :message => output_message)
         end
         unless error_message.empty?
-          Engine.log.error("[output][groonga][error]",
-                           :context => context,
-                           :message => error_message)
+          $log.error("[output][groonga][error]",
+                     :context => context,
+                     :message => error_message)
         end
       end
     end

data/sample/store-apache.conf

@@ -0,0 +1,239 @@
+<source>
+  type forward
+</source>
+
+<source>
+  type tail
+  path /var/log/apache2/access.log
+  pos_file /tmp/apache_access.pos
+  tag apache.raw.log.apache.access
+  format apache2
+  # read_from_head true
+</source>
+
+<match apache.**>
+  type record_reformer
+  enable_ruby false
+
+  tag ${tag_suffix[1]}
+
+  <record>
+    remote ${host}
+  </record>
+</match>
+
+<match raw.log.**>
+  type record_reformer
+  enable_ruby false
+
+  tag ${tag_suffix[1]}
+
+  <record>
+    host ${hostname}
+    type ${tag_suffix[2]}
+    timestamp ${time}
+  </record>
+</match>
+
+<match log.**>
+  type groonga
+  store_table Logs
+
+  protocol http
+  host 127.0.0.1
+
+  buffer_type file
+  buffer_path /tmp/buffer
+  flush_interval 1
+
+  <table>
+    name Codes
+    flags TABLE_PAT_KEY
+    key_type Int32
+  </table>
+
+  <table>
+    name Hosts
+    flags TABLE_PAT_KEY
+    key_type ShortText
+    normalizer NormalizerAuto
+  </table>
+
+  <table>
+    name URLs
+    flags TABLE_PAT_KEY
+    key_type ShortText
+  </table>
+
+  <table>
+    name Paths
+    flags TABLE_PAT_KEY
+    key_type ShortText
+  </table>
+
+  <table>
+    name UserAgents
+    flags TABLE_PAT_KEY
+    key_type ShortText
+  </table>
+
+  <table>
+    name Methods
+    flags TABLE_HASH_KEY
+    key_type ShortText
+    normalizer NormalizerAuto
+  </table>
+
+  <table>
+    name Remotes
+    flags TABLE_PAT_KEY
+    key_type ShortText
+  </table>
+
+  <table>
+    name Sizes
+    flags TABLE_PAT_KEY
+    key_type Int32
+  </table>
+
+  <table>
+    name Timestamps
+    flags TABLE_PAT_KEY
+    key_type Time
+  </table>
+
+  <table>
+    name Types
+    flags TABLE_PAT_KEY
+    key_type ShortText
+  </table>
+
+  <table>
+    name Terms
+    flags TABLE_PAT_KEY
+    key_type ShortText
+    default_tokenizer TokenBigram
+    normalizer NormalizerAuto
+    <index>
+      name host_index
+      source_table Hosts
+      source_columns _key
+    </index>
+    <index>
+      name url_index
+      source_table URLs
+      source_columns _key
+    </index>
+    <index>
+      name path_index
+      source_table Paths
+      source_columns _key
+    </index>
+    <index>
+      name user_agent_index
+      source_table UserAgents
+      source_columns _key
+    </index>
+  </table>
+
+  <mapping>
+    name agent
+    type UserAgents
+    <index>
+      table Terms
+      name logs_agent_index
+      flags WITH_POSITION
+    </index>
+  </mapping>
+
+  <mapping>
+    name code
+    type Codes
+    <index>
+      table Codes
+      name logs_index
+    </index>
+  </mapping>
+
+  <mapping>
+    name host
+    type Hosts
+    <index>
+      table Hosts
+      name hosts_index
+    </index>
+  </mapping>
+
+  <mapping>
+    name message
+    type Text
+    <index>
+      table Terms
+      name logs_message_index
+      flags WITH_POSITION
+    </index>
+  </mapping>
+
+  <mapping>
+    name method
+    type Methods
+    <index>
+      table Methods
+      name logs_index
+    </index>
+  </mapping>
+
+  <mapping>
+    name path
+    type Paths
+    <index>
+      table Paths
+      name logs_index
+    </index>
+  </mapping>
+
+  <mapping>
+    name referer
+    type URLs
+    <index>
+      table URLs
+      name logs_index
+    </index>
+  </mapping>
+
+  <mapping>
+    name remote
+    type Remotes
+    <index>
+      table Remotes
+      name logs_index
+    </index>
+  </mapping>
+
+  <mapping>
+    name size
+    type Int32
+    <index>
+      table Sizes
+      name logs_index
+    </index>
+  </mapping>
+
+  <mapping>
+    name timestamp
+    type Time
+    <index>
+      table Timestamps
+      name logs_index
+    </index>
+  </mapping>
+
+  <mapping>
+    name type
+    type Types
+    <index>
+      table Types
+      name logs_index
+    </index>
+  </mapping>
+</match>

data/sample/store.conf

@@ -4,7 +4,7 @@
 
 <match log.*>
   type groonga
-  table Logs
+  store_table Logs
 
   protocol http
   host 127.0.0.1

data/test/output/test_table_definition.rb

@@ -0,0 +1,167 @@
+# Copyright (C) 2014  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "fluent/plugin/out_groonga"
+
+class OutputTypeTableDefinitionTest < Test::Unit::TestCase
+  def definition(raw={})
+    Fluent::GroongaOutput::TableDefinition.new(raw)
+  end
+
+  sub_test_case "readers" do
+    sub_test_case "\#name" do
+      test "specified" do
+        assert_equal("Tags", definition(:name => "Tags").name)
+      end
+    end
+
+    sub_test_case "\#flags" do
+      test "default" do
+        assert_equal(["TABLE_NO_KEY"],
+                     definition.flags)
+      end
+
+      test "one" do
+        assert_equal(["TABLE_PAT_KEY"],
+                     definition(:flags => "TABLE_PAT_KEY").flags)
+      end
+    end
+
+    sub_test_case "\#key_type" do
+      test "default" do
+        assert_nil(definition.key_type)
+      end
+
+      test "specified" do
+        assert_equal("ShortText",
+                     definition(:key_type => "ShortText").key_type)
+      end
+    end
+
+    sub_test_case "\#default_tokenizer" do
+      def read_default_tokenizer(input)
+        definition(:default_tokenizer => input).default_tokenizer
+      end
+
+      test "default" do
+        assert_nil(definition.default_tokenizer)
+      end
+
+      test "specified" do
+        assert_equal("TokenBigram",
+                     read_default_tokenizer("TokenBigram"))
+      end
+    end
+
+    sub_test_case "\#token_filters" do
+      def read_token_filters(input)
+        definition(:token_filters => input).token_filters
+      end
+
+      test "default" do
+        assert_equal([], definition.token_filters)
+      end
+
+      test "one" do
+        assert_equal(["TokenFilterStem"],
+                      read_token_filters("TokenFilterStem"))
+      end
+
+      test "multiple" do
+        assert_equal(["TokenFilterStem", "TokenFilterStopWord"],
+                      read_token_filters("TokenFilterStem,TokenFilterStopWord"))
+      end
+    end
+
+    sub_test_case "\#normalizer" do
+      def read_normalizer(input)
+        definition(:normalizer => input).normalizer
+      end
+
+      test "default" do
+        assert_nil(definition.normalizer)
+      end
+
+      test "specified" do
+        assert_equal("NormalizerAuto",
+                     read_normalizer("NormalizerAuto"))
+      end
+    end
+  end
+
+  sub_test_case "\#have_difference?" do
+    def setup
+      @existing_table = Groonga::Client::Response::TableList::Table.new
+      @existing_table.id = 260
+      @existing_table.name = "Paths"
+      @existing_table.path = "/var/lib/groonga/db/db.0000104"
+      @existing_table.flags = "TABLE_PAT_KEY|PERSISTENT"
+      @existing_table.domain = "ShortText"
+      @existing_table.range = nil
+      @existing_table.default_tokenizer = nil
+      @existing_table.normalizer = nil
+    end
+
+    def have_difference?(raw={})
+      default_raw = {
+        :name              => @existing_table.name,
+        :flags             => @existing_table.flags.gsub(/\|PERSISTENT/, ""),
+        :key_type          => @existing_table.domain,
+        :default_tokenizer => @existing_table.default_tokenizer,
+        :normalizer        => @existing_table.normalizer,
+      }
+      raw = default_raw.merge(raw)
+      definition(raw).have_difference?(@existing_table)
+    end
+
+    test "no difference" do
+      assert do
+        not have_difference?
+      end
+    end
+
+    sub_test_case "difference" do
+      test "name" do
+        assert do
+          have_difference?(:name => "Difference")
+        end
+      end
+
+      test "flags" do
+        assert do
+          have_difference?(:flags => "TABLE_NO_KEY")
+        end
+      end
+
+      test "key_type" do
+        assert do
+          have_difference?(:key_type => "UInt32")
+        end
+      end
+
+      test "default_tokenizer" do
+        assert do
+          have_difference?(:default_tokenizer => "TokenBigram")
+        end
+      end
+
+      test "normalizer" do
+        assert do
+          have_difference?(:normalizer => "NormalizerAuto")
+        end
+      end
+    end
+  end
+end

data/test/output/test_type_guesser.rb

@@ -122,11 +122,30 @@ class OutputTypeGuesserTest < Test::Unit::TestCase
       end
     end
 
+    sub_test_case "ShortText" do
+      test "max" do
+        message = "X" * (2 ** 12)
+        assert_equal("ShortText", guess([message]))
+      end
+    end
+
     sub_test_case "Text" do
-      test "message" do
-        message = "failed to load data"
+      test "min" do
+        message = "X" * (2 ** 12 + 1)
         assert_equal("Text", guess([message]))
       end
+
+      test "max" do
+        message = "X" * (2 ** 16)
+        assert_equal("Text", guess([message]))
+      end
+    end
+
+    sub_test_case "LongText" do
+      test "min" do
+        message = "X" * (2 ** 16 + 1)
+        assert_equal("LongText", guess([message]))
+      end
     end
   end
 end

data/test/run-test.rb

@@ -30,13 +30,8 @@ Test::Unit::Priority.enable
 
 $LOAD_PATH.unshift(lib_dir)
 
-require "fluent/log"
-$log = Fluent::Log.new($stdout, Fluent::Log::LEVEL_WARN)
-
-Dir.glob("#{base_dir}/test/**/test{_,-}*.rb") do |file|
-  require file.sub(/\.rb$/, '')
-end
+require "fluent/test"
 
 ENV["TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"] ||= "5000"
 
-exit Test::Unit::AutoRunner.run
+exit(Test::Unit::AutoRunner.run(true, test_dir))

data/test/test_output.rb

@@ -111,7 +111,7 @@ EOC
       def configuration
         <<-CONFIGURATION
           #{super}
-          table Logs
+          store_table Logs
         CONFIGURATION
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-groonga
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
 platform: ruby
 authors:
 - Kouhei Sutou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-21 00:00:00.000000000 Z
+date: 2014-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: groonga-command-parser
   requirement: !ruby/object:Gem::Requirement
@@ -157,7 +157,9 @@ files:
 - sample/command.conf
 - sample/gqtp.conf
 - sample/http.conf
+- sample/store-apache.conf
 - sample/store.conf
+- test/output/test_table_definition.rb
 - test/output/test_type_guesser.rb
 - test/run-test.rb
 - test/test_input.rb
@@ -192,4 +194,5 @@ test_files:
 - test/test_input.rb
 - test/run-test.rb
 - test/output/test_type_guesser.rb
+- test/output/test_table_definition.rb
 has_rdoc: