fluent-plugin-mysql-replicator 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea8d93c147df39ff2c34ac573a5e981c1e0a46da8445395eaf38cdc44abf7c0e
-  data.tar.gz: f190b88e93c4318b9c2ec42863186f7dc1f0a3a911bb60e2b689a84687bffdcd
+  metadata.gz: 26f611dc962db43660ca6004ce2b634e9a863d554ff25328d7d39e1bc4c5a14e
+  data.tar.gz: dd4834e5c827564da74189882a605381fbe9be31b1755cc772ceb9bed0c09937
 SHA512:
-  metadata.gz: bfbf04041525c768d56c7b0bb3d2cd69ca23076eca57d162277d81a06c1cb4290e4b0d402e46e4b136ebf2d45b8fdca59555c1406c9763336b67f3cf2b4be35d
-  data.tar.gz: 2872f2e0d15084d3680a77498411aa5165acb000b2b5744be19686a2dcd89b41ccee8169956203bb3b9c9a004b0aba6d16d741147215b518e0690889b220ab98
+  metadata.gz: efc707ef5d9f6606baa7d573d974701bd1cedb4e34bf6a67ebda681c313b190d88ca700c505857526694b216759093cf5f834486c065074a99adb3705d5b076f
+  data.tar.gz: 17bec8dd052fb658430c1cd4d15c7731c5f7afaf27a62add1e56b6e6134f928bc5934d5db825a2918a894b0ff2f3504fe9b120ff19eaa9ca89f3c8f93d1d84b5

data/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] - 2026-06-17
+
+### Added
+- Plugin-managed Elasticsearch index templates. New `template_name`,
+  `template_file`, `template_overwrite`, and `use_legacy_template` options on
+  `mysql_replicator_elasticsearch` install an index template on startup, so newly
+  created indices — including future date-rolled ones — get the desired mapping
+  before the first document locks in dynamic mapping. This enables mappings that
+  cannot be changed after the fact: `keyword` / non-analyzed fields ([#20]) and
+  `geo_point` ([#36]). `use_legacy_template` defaults to `false` (composable
+  `PUT /_index_template`, Elasticsearch >= 7.8); set it to `true` for the legacy
+  `PUT /_template` API (Elasticsearch 6.x+).
+
+### Documentation
+- Document that MySQL `DECIMAL` columns are emitted as strings (because
+  `BigDecimal` cannot cross Fluentd's msgpack buffer, which also preserves exact
+  precision) and should be mapped as `double` or `scaled_float` in an index
+  template, where Elasticsearch coerces the numeric string at index time. ([#36])
+
+## [1.3.0] - 2026-06-16
+
+### Added
+- Date-based Elasticsearch index names. If the index-name segment of the tag
+  contains `strftime` tokens (e.g. `%Y%m%d`), they are expanded using the
+  record's event time, enabling Logstash-style dated indices such as
+  `myindex-20180831`. Index names without a `%` are unchanged. ([#27])
+- Composite primary key support in `mysql_replicator`. `primary_key` now accepts
+  a comma-separated list of columns; the combination is used for change
+  detection and as the Elasticsearch document `_id` (values joined by `,`). A
+  single-column key behaves exactly as before. ([#7])
+
 ## [1.2.0] - 2026-06-16
 
 ### Added
@@ -73,6 +104,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - First 1.0 release, targeting the Fluentd v0.14+ plugin API. Earlier 0.x
   history is available in the git log.
 
+[1.4.0]: https://github.com/y-ken/fluent-plugin-mysql-replicator/compare/v1.3.0...v1.4.0
+[1.3.0]: https://github.com/y-ken/fluent-plugin-mysql-replicator/compare/v1.2.0...v1.3.0
 [1.2.0]: https://github.com/y-ken/fluent-plugin-mysql-replicator/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/y-ken/fluent-plugin-mysql-replicator/compare/v1.0.3...v1.1.0
 [1.0.3]: https://github.com/y-ken/fluent-plugin-mysql-replicator/compare/v1.0.2...v1.0.3
@@ -81,7 +114,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [1.0.0]: https://github.com/y-ken/fluent-plugin-mysql-replicator/releases/tag/v1.0.0
 
 [#4]: https://github.com/y-ken/fluent-plugin-mysql-replicator/issues/4
+[#7]: https://github.com/y-ken/fluent-plugin-mysql-replicator/pull/7
 [#18]: https://github.com/y-ken/fluent-plugin-mysql-replicator/pull/18
+[#20]: https://github.com/y-ken/fluent-plugin-mysql-replicator/issues/20
+[#27]: https://github.com/y-ken/fluent-plugin-mysql-replicator/issues/27
+[#36]: https://github.com/y-ken/fluent-plugin-mysql-replicator/issues/36
 [#39]: https://github.com/y-ken/fluent-plugin-mysql-replicator/pull/39
 [#40]: https://github.com/y-ken/fluent-plugin-mysql-replicator/issues/40
 [#42]: https://github.com/y-ken/fluent-plugin-mysql-replicator/issues/42

data/README.md

@@ -122,6 +122,117 @@ Notes:
 * Malformed JSON and non-string values are left untouched, so enabling the option
   never corrupts non-JSON data.
 
+## Date-based index names
+
+`mysql_replicator_elasticsearch` resolves the target index name from the tag
+(via `tag_format`). If that index-name segment contains `strftime` tokens such
+as `%Y%m%d`, they are expanded using the record's event time, so you can create
+Logstash-style dated indices like `myindex-20180831`.
+
+Put the tokens in the index-name part of the input plugin's `tag` (the segment
+must not contain `.`, so use `%Y%m%d` or `%Y-%m-%d`):
+
+```
+<source>
+  @type mysql_replicator
+  # ...
+  tag   myindex-%Y%m%d.mytype.${event}.${primary_key}
+</source>
+```
+
+Index names that contain no `%` are left unchanged, so this is fully backward
+compatible.
+
+> **Note on deletions:** delete events target the index computed from the delete
+> event's own time, so date-rotated indices are best suited to insert-only data
+> (a record inserted on a previous day lives in that day's index).
+
+## Composite primary keys
+
+`primary_key` accepts a comma-separated list of columns, so tables keyed by more
+than one column are supported:
+
+```
+<source>
+  @type        mysql_replicator
+  # ...
+  query        SELECT tenant_id, id, name FROM items
+  primary_key  tenant_id,id
+</source>
+```
+
+Change detection (insert/update/delete) then keys on the combination of those
+columns, and the Elasticsearch document `_id` becomes their values joined by `,`
+(e.g. `10,7`). A single-column `primary_key` (the default `id`) behaves exactly
+as before.
+
+This applies to `mysql_replicator`; `mysql_replicator_multi` still expects a
+single-column primary key.
+
+## Index templates (mappings)
+
+By default Elasticsearch infers field types from the first document (dynamic
+mapping), and an existing field's mapping cannot be changed afterwards. To
+control a field's mapping — e.g. `keyword` for a non-analyzed field, or
+`geo_point`, which dynamic mapping never infers — install an **index template**
+so it is applied to indices *before* the first document is written.
+
+`mysql_replicator_elasticsearch` can install a template on startup. The option
+names mirror `fluent-plugin-elasticsearch` (the default here uses the modern
+composable API, whereas fluent-plugin-elasticsearch defaults to legacy):
+
+```
+<match replicator.**>
+  @type mysql_replicator_elasticsearch
+  # ...
+  template_name        myindex_template
+  template_file        /etc/fluent/myindex_template.json
+  template_overwrite   false   # set true to replace an existing template
+  use_legacy_template  false   # default. false: PUT /_index_template (ES >= 7.8); true: PUT /_template (legacy, ES 6.x+)
+</match>
+```
+
+`template_name` and `template_file` must be set together. The template is a
+**server-side rule**, so once installed it is applied automatically to every new
+index whose name matches its `index_patterns` — **including future date-rolled
+indices** (see *Date-based index names* above) — with no per-write work.
+
+Example `template_file` (composable format, the default) mapping a non-analyzed
+field as `keyword`, a coordinate field as `geo_point`, and a `DECIMAL` column as
+a numeric (see below):
+
+```json
+{
+  "index_patterns": ["myindex-*"],
+  "template": {
+    "mappings": {
+      "properties": {
+        "message":  { "type": "keyword" },
+        "location": { "type": "geo_point" },
+        "price":    { "type": "scaled_float", "scaling_factor": 100 }
+      }
+    }
+  }
+}
+```
+
+For Elasticsearch 6.x — or to reuse an existing `fluent-plugin-elasticsearch`
+legacy template — set `use_legacy_template true` and put `settings`/`mappings`
+at the top level (not under `template`).
+
+### Numeric columns (DECIMAL)
+
+MySQL `DECIMAL` columns are sent to Elasticsearch **as strings** — not because of
+a type-inference issue, but because `BigDecimal` cannot cross Fluentd's msgpack
+buffer between the input and output plugins, so the value is stringified (which
+also preserves its exact precision). Under the default dynamic mapping such a
+field is therefore indexed as text.
+
+To index it as a number, map the field in your template as `double`, or — to keep
+exact fixed-point precision — `scaled_float` (as `price` above). Elasticsearch's
+`coerce` (enabled by default for numeric types) converts the numeric string to a
+number at index time, so no value conversion is needed in the plugin.
+
 ## Output example
 
 It is a example when detecting insert/update/delete events.

data/fluent-plugin-mysql-replicator.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name        = "fluent-plugin-mysql-replicator"
-  s.version     = "1.2.0"
+  s.version     = "1.4.0"
   s.authors     = ["Kentaro Yoshida"]
   s.email       = ["y.ken.studio@gmail.com"]
   s.homepage    = "https://github.com/y-ken/fluent-plugin-mysql-replicator"

data/lib/fluent/plugin/in_mysql_replicator.rb

@@ -17,7 +17,10 @@ module Fluent::Plugin
     config_param :encoding, :string, :default => 'utf8'
     config_param :query, :string
     config_param :prepared_query, :string, :default => nil
-    config_param :primary_key, :string, :default => 'id'
+    # A single column name, or a comma-separated list for a composite key
+    # (e.g. "tenant_id,id"). The id used for change detection and the
+    # Elasticsearch document _id is the combination of these columns.
+    config_param :primary_key, :array, :default => ['id']
     config_param :interval, :string, :default => '1m'
     config_param :enable_delete, :bool, :default => true
     # Comma-separated column names whose MySQL JSON values should be parsed into
@@ -73,7 +76,8 @@ module Fluent::Plugin
         end
         rows, con = query(@query, con)
         rows.each do |row|
-          current_ids << row[@primary_key]
+          id = extract_id(row)
+          current_ids << id
           current_hash = Digest::SHA1.hexdigest(row.flatten.join)
           row.each {|k, v| row[k] = v.to_s if v.is_a?(Time) || v.is_a?(Date) || v.is_a?(BigDecimal)}
           parse_json_columns!(row, @json_columns)
@@ -86,18 +90,18 @@ module Fluent::Plugin
             end
             prepared_con.close
           end
-          if row[@primary_key].nil?
-            log.error "mysql_replicator: missing primary_key. :tag=>#{tag} :primary_key=>#{primary_key}"
+          if id.any?(&:nil?)
+            log.error "mysql_replicator: missing primary_key. :tag=>#{tag} :primary_key=>#{@primary_key.join(',')} :id=>#{id}"
             break
           end
-          if !table_hash.include?(row[@primary_key])
+          if !table_hash.include?(id)
             tag = format_tag(@tag, {:event => :insert})
             emit_record(tag, row)
-          elsif table_hash[row[@primary_key]] != current_hash
+          elsif table_hash[id] != current_hash
             tag = format_tag(@tag, {:event => :update})
             emit_record(tag, row)
           end
-          table_hash[row[@primary_key]] = current_hash
+          table_hash[id] = current_hash
           rows_count += 1
         end
         con.close
@@ -108,7 +112,7 @@ module Fluent::Plugin
             hash_delete_by_list(table_hash, deleted_ids)
             deleted_ids.each do |id|
               tag = format_tag(@tag, {:event => :delete})
-              emit_record(tag, {@primary_key => id})
+              emit_record(tag, Hash[@primary_key.zip(id)])
             end
           end
         end
@@ -122,6 +126,12 @@ module Fluent::Plugin
       deleted_keys.each{|k| hash.delete(k)}
     end
 
+    # A row's id is the array of its primary-key column values, supporting
+    # composite keys. It is a single-element array for a single-column key.
+    def extract_id(row)
+      @primary_key.map {|col| row[col] }
+    end
+
     # Returns the primary keys that disappeared since the previous poll.
     #
     # The first poll only establishes a baseline: there is no previous snapshot
@@ -152,7 +162,7 @@ module Fluent::Plugin
     end
 
     def format_tag(tag, param)
-      pattern = {'${event}' => param[:event].to_s, '${primary_key}' => @primary_key}
+      pattern = {'${event}' => param[:event].to_s, '${primary_key}' => @primary_key.join(',')}
       tag.gsub(/(\${[a-z_]+})/) do
         log.warn "mysql_replicator: missing placeholder. :tag=>#{tag} :placeholder=>#{$1}" unless pattern.include?($1)
         pattern[$1]

data/lib/fluent/plugin/out_mysql_replicator_elasticsearch.rb

@@ -17,6 +17,20 @@ class Fluent::Plugin::MysqlReplicatorElasticsearchOutput < Fluent::Plugin::Outpu
   config_param :username, :string, :default => nil
   config_param :password, :string, :default => nil, :secret => true
 
+  # Optional: install an Elasticsearch index template on startup so that newly
+  # created indices (including future date-rolled ones) get the desired mapping
+  # (e.g. geo_point or keyword fields) before the first document locks in
+  # dynamic mapping. template_name and template_file must be set together.
+  #
+  # Parameter names mirror fluent-plugin-elasticsearch. The default uses the
+  # modern composable API (fluent-plugin-elasticsearch defaults to legacy):
+  #   use_legacy_template false (default) -> PUT /_index_template/<name>  (composable, ES >= 7.8)
+  #   use_legacy_template true            -> PUT /_template/<name>        (legacy, ES 6.x+)
+  config_param :template_name, :string, :default => nil
+  config_param :template_file, :string, :default => nil
+  config_param :template_overwrite, :bool, :default => false
+  config_param :use_legacy_template, :bool, :default => false
+
   config_section :buffer do
     config_set_default :@type, DEFAULT_BUFFER_TYPE
   end
@@ -35,12 +49,21 @@ class Fluent::Plugin::MysqlReplicatorElasticsearchOutput < Fluent::Plugin::Outpu
     else
       @tag_format = Regexp.new(conf['tag_format'])
     end
+
+    if @template_name.nil? != @template_file.nil?
+      raise Fluent::ConfigError, "mysql_replicator_elasticsearch: 'template_name' and 'template_file' must be set together"
+    end
+    if @template_file && !File.exist?(@template_file)
+      raise Fluent::ConfigError, "mysql_replicator_elasticsearch: template_file not found: #{@template_file}"
+    end
   end
 
   def start
     super
     # nil means "not yet detected"; resolved on the first write.
     @suppress_type = nil
+    @es_version = nil
+    @template_installed = false
   end
 
   def format(tag, time, record)
@@ -61,25 +84,26 @@ class Fluent::Plugin::MysqlReplicatorElasticsearchOutput < Fluent::Plugin::Outpu
 
   def write(chunk)
     detect_type_suppression if @suppress_type.nil?
+    install_template_once if @template_name
 
     bulk_message = []
 
     chunk.msgpack_each do |tag, time, record|
       tag_parts = tag.match(@tag_format)
-      target_index = tag_parts['index_name']
+      target_index = resolve_index_name(tag_parts['index_name'], time)
       target_type = tag_parts['type_name']
-      id_key = tag_parts['primary_key']
+      id_keys = tag_parts['primary_key'].to_s.split(',')
 
       if tag_parts['event'] == 'delete'
-        action = {"_index" => target_index, "_id" => record[id_key]}
+        action = {"_index" => target_index, "_id" => join_id(record, id_keys)}
         action['_type'] = target_type unless @suppress_type
         meta = { "delete" => action }
         bulk_message << Yajl::Encoder.encode(meta)
       else
         action = {"_index" => target_index}
         action['_type'] = target_type unless @suppress_type
-        if id_key && record[id_key]
-          action['_id'] = record[id_key]
+        if !id_keys.empty? && id_keys.all? {|k| !record[k].nil? }
+          action['_id'] = join_id(record, id_keys)
         end
         meta = { "index" => action }
         bulk_message << Yajl::Encoder.encode(meta)
@@ -105,26 +129,94 @@ class Fluent::Plugin::MysqlReplicatorElasticsearchOutput < Fluent::Plugin::Outpu
     http
   end
 
+  # Build the document _id from one or more primary-key columns. A single key
+  # yields its value; a composite key yields the values joined by ",".
+  def join_id(record, id_keys)
+    id_keys.map {|k| record[k] }.join(',')
+  end
+
+  # Expand strftime tokens (e.g. "%Y%m%d") in the index name using the record's
+  # event time, enabling date-based indices such as "myindex-20180831". Index
+  # names without a "%" are returned unchanged.
+  def resolve_index_name(index_name, time)
+    return index_name unless index_name && index_name.include?('%')
+    Time.at(time.to_i).strftime(index_name)
+  rescue => e
+    log.warn "mysql_replicator_elasticsearch: failed to expand index name '#{index_name}': #{e.message}"
+    index_name
+  end
+
   # Mapping types were removed in Elasticsearch 8.x and deprecated in 7.x.
-  # Detect the major version once and omit "_type" for 7.x and later.
+  # Detect the version once and omit "_type" for 7.x and later.
   def detect_type_suppression
-    major = elasticsearch_major_version
+    @es_version = elasticsearch_version
+    major = @es_version&.first
     @suppress_type = !major.nil? && major >= 7
     if major
-      log.info "mysql_replicator_elasticsearch: detected Elasticsearch #{major}.x, suppress_type=#{@suppress_type}"
+      log.info "mysql_replicator_elasticsearch: detected Elasticsearch #{@es_version.join('.')}, suppress_type=#{@suppress_type}"
     else
       log.warn "mysql_replicator_elasticsearch: could not detect Elasticsearch version, sending '_type' (assuming 6.x)"
     end
   end
 
-  def elasticsearch_major_version
+  # Returns the Elasticsearch version as [major, minor], or nil if undetectable.
+  def elasticsearch_version
     request = Net::HTTP::Get.new('/')
     request.basic_auth(@username, @password) if @username && @password
     response = new_http.request(request)
     number = Yajl::Parser.parse(response.body).dig('version', 'number')
-    number.to_s.split('.').first.to_i
+    return nil if number.nil?
+    number.to_s.split('.').first(2).map(&:to_i)
   rescue => e
     log.warn "mysql_replicator_elasticsearch: version detection failed: #{e.message}"
     nil
   end
+
+  # Install the configured index template once, on the first write. The template
+  # is a server-side rule, so Elasticsearch applies it to every new index whose
+  # name matches its index_patterns -- including future date-rolled indices --
+  # without any further action here. Failures are logged but never abort indexing.
+  def install_template_once
+    return if @template_installed
+    @template_installed = true
+    install_template
+  rescue => e
+    log.warn "mysql_replicator_elasticsearch: failed to install index template '#{@template_name}': #{e.message}"
+  end
+
+  def install_template
+    if !@use_legacy_template && !composable_templates_supported?
+      log.warn "mysql_replicator_elasticsearch: composable index templates require Elasticsearch >= 7.8; skipping template '#{@template_name}' (detected #{@es_version&.join('.') || 'unknown'}). Set 'use_legacy_template true' for older Elasticsearch."
+      return
+    end
+    if !@template_overwrite && template_exists?
+      log.info "mysql_replicator_elasticsearch: index template '#{@template_name}' already exists; skipping (set 'template_overwrite true' to replace)"
+      return
+    end
+    put_template(File.read(@template_file))
+    log.info "mysql_replicator_elasticsearch: installed index template '#{@template_name}' (#{@use_legacy_template ? 'legacy' : 'composable'})"
+  end
+
+  def composable_templates_supported?
+    return false if @es_version.nil?
+    major, minor = @es_version
+    major > 7 || (major == 7 && minor >= 8)
+  end
+
+  def template_path
+    @use_legacy_template ? "/_template/#{@template_name}" : "/_index_template/#{@template_name}"
+  end
+
+  def template_exists?
+    request = Net::HTTP::Get.new(template_path)
+    request.basic_auth(@username, @password) if @username && @password
+    new_http.request(request).code.to_i == 200
+  end
+
+  def put_template(body)
+    request = Net::HTTP::Put.new(template_path, {'content-type' => 'application/json; charset=utf-8'})
+    request.basic_auth(@username, @password) if @username && @password
+    request.body = body
+    new_http.request(request).value
+  end
 end

data/test/plugin/test_in_mysql_replicator.rb

@@ -137,4 +137,30 @@ class MysqlReplicatorInputTest < Test::Unit::TestCase
     assert_false nested?(12345)
     assert_false nested?(nil)
   end
+
+  # --- #7: composite primary key support ---
+
+  def composite_driver
+    create_driver(%[
+      tag         input.mysql
+      query       SELECT tenant_id, id, text from t
+      primary_key tenant_id,id
+    ])
+  end
+
+  def test_primary_key_defaults_to_id_array
+    assert_equal ['id'], create_driver.instance.primary_key
+  end
+
+  def test_primary_key_parses_composite_list
+    assert_equal ['tenant_id', 'id'], composite_driver.instance.primary_key
+  end
+
+  def test_extract_id_single_key_is_one_element_array
+    assert_equal [7], create_driver.instance.extract_id({'id' => 7, 'text' => 'x'})
+  end
+
+  def test_extract_id_returns_composite_values
+    assert_equal [10, 7], composite_driver.instance.extract_id({'tenant_id' => 10, 'id' => 7, 'text' => 'x'})
+  end
 end

data/test/plugin/test_out_mysql_replicator_elasticsearch.rb

@@ -1,6 +1,7 @@
 require 'helper'
 require 'fluent/test/driver/output'
 require 'webmock/test_unit'
+require 'tempfile'
 
 WebMock.disable_net_connect!
 
@@ -13,6 +14,19 @@ class MysqlReplicatorElasticsearchOutput < Test::Unit::TestCase
     @tag = 'myindex.mytype.insert.id'
   end
 
+  def teardown
+    WebMock.reset!
+    (@tmpfiles || []).each {|f| f.close! rescue nil }
+  end
+
+  def write_template_file(body = '{"index_patterns":["myindex-*"],"mappings":{"properties":{"loc":{"type":"geo_point"}}}}')
+    file = Tempfile.new(['tmpl', '.json'])
+    file.write(body)
+    file.flush
+    (@tmpfiles ||= []) << file
+    file.path
+  end
+
   def driver(conf='')
     @driver ||= Fluent::Test::Driver::Output.new(Fluent::Plugin::MysqlReplicatorElasticsearchOutput).configure(conf)
   end
@@ -61,6 +75,32 @@ class MysqlReplicatorElasticsearchOutput < Test::Unit::TestCase
     assert_equal('myindex', index_cmds.first['index']['_index'])
   end
 
+  def test_expands_strftime_tokens_in_index_name
+    stub_elastic
+    time = Time.utc(2018, 8, 31, 12, 0, 0).to_i
+    driver.run(default_tag: 'myindex-%Y%m%d.mytype.insert.id') do
+      driver.feed(time, sample_record)
+    end
+    expected = "myindex-#{Time.at(time).strftime('%Y%m%d')}"
+    assert_equal(expected, index_cmds.first['index']['_index'])
+  end
+
+  def test_index_name_without_token_is_unchanged
+    stub_elastic
+    driver.run(default_tag: 'plainindex.mytype.insert.id') do
+      driver.feed(sample_record)
+    end
+    assert_equal('plainindex', index_cmds.first['index']['_index'])
+  end
+
+  def test_composite_primary_key_builds_joined_id
+    stub_elastic
+    driver.run(default_tag: 'myindex.mytype.insert.tenant_id,id') do
+      driver.feed({'tenant_id' => 10, 'id' => 7, 'text' => 'x'})
+    end
+    assert_equal('10,7', index_cmds.first['index']['_id'])
+  end
+
   def test_writes_to_speficied_type
     driver.configure("type_name mytype\n")
     stub_elastic
@@ -161,6 +201,49 @@ class MysqlReplicatorElasticsearchOutput < Test::Unit::TestCase
     }
   end
 
+  def test_installs_composable_template_by_default
+    stub_elastic
+    stub_elastic_version("http://localhost:9200/", "8.18.0")
+    stub_request(:get, "http://localhost:9200/_index_template/my_tmpl").to_return(:status => 404)
+    put_tmpl = stub_request(:put, "http://localhost:9200/_index_template/my_tmpl").to_return(:status => 200, :body => "{}")
+    driver.configure("template_name my_tmpl\ntemplate_file #{write_template_file}\n")
+    driver.run(default_tag: @tag) { driver.feed(sample_record) }
+    assert_requested(put_tmpl)
+  end
+
+  def test_installs_legacy_template_when_enabled
+    stub_elastic # version 6.8.23
+    stub_request(:get, "http://localhost:9200/_template/my_tmpl").to_return(:status => 404)
+    put_tmpl = stub_request(:put, "http://localhost:9200/_template/my_tmpl").to_return(:status => 200, :body => "{}")
+    driver.configure("template_name my_tmpl\ntemplate_file #{write_template_file}\nuse_legacy_template true\n")
+    driver.run(default_tag: @tag) { driver.feed(sample_record) }
+    assert_requested(put_tmpl)
+  end
+
+  def test_skips_composable_template_on_old_elasticsearch
+    stub_elastic # version 6.8.23 (< 7.8), default composable
+    put_tmpl = stub_request(:put, "http://localhost:9200/_index_template/my_tmpl")
+    driver.configure("template_name my_tmpl\ntemplate_file #{write_template_file}\n")
+    driver.run(default_tag: @tag) { driver.feed(sample_record) }
+    assert_not_requested(put_tmpl)
+  end
+
+  def test_skips_template_when_it_exists_and_no_overwrite
+    stub_elastic
+    stub_elastic_version("http://localhost:9200/", "8.18.0")
+    stub_request(:get, "http://localhost:9200/_index_template/my_tmpl").to_return(:status => 200, :body => "{}")
+    put_tmpl = stub_request(:put, "http://localhost:9200/_index_template/my_tmpl")
+    driver.configure("template_name my_tmpl\ntemplate_file #{write_template_file}\n")
+    driver.run(default_tag: @tag) { driver.feed(sample_record) }
+    assert_not_requested(put_tmpl)
+  end
+
+  def test_template_name_without_file_raises
+    assert_raise(Fluent::ConfigError) do
+      driver.configure("template_name my_tmpl\n")
+    end
+  end
+
   def test_writes_to_https_host
     driver.configure("ssl true\n")
     elastic_request = stub_elastic("https://localhost:9200/_bulk")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-mysql-replicator
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Kentaro Yoshida
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-16 00:00:00.000000000 Z
+date: 2026-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake