├── .gitignore
├── .travis.yml
├── Gemfile
├── LICENSE.txt
├── README.md
├── Rakefile
├── example
    ├── file.conf
    └── sample.conf
├── fluent-plugin-forest.gemspec
├── lib
    └── fluent
    │   └── plugin
    │       └── out_forest.rb
└── test
    ├── helper.rb
    ├── output
        └── out_forest_test.rb
    └── plugin
        ├── test_out_forest.rb
        └── test_out_forest_test.rb


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.gem
 2 | *.rbc
 3 | .bundle
 4 | .config
 5 | .yardoc
 6 | Gemfile.lock
 7 | InstalledFiles
 8 | _yardoc
 9 | coverage
10 | doc/
11 | lib/bundler/man
12 | pkg
13 | rdoc
14 | spec/reports
15 | test/tmp
16 | test/version_tmp
17 | tmp
18 | # For TextMate, emacs, vim
19 | *.tmproj
20 | tmtags
21 | *~
22 | \#*
23 | .\#*
24 | *.swp
25 | 
26 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: ruby
2 | sudo: false
3 | rvm:
4 |   - 2.1
5 |   - 2.2
6 |   - 2.3.0
7 | before_install:
8 |   - gem update bundler
9 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source 'https://rubygems.org'
2 | 
3 | # Specify your gem's dependencies in fluent-plugin-forest.gemspec
4 | gemspec
5 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2012- TAGOMORI Satoshi
 2 | 
 3 |    Licensed under the Apache License, Version 2.0 (the "License");
 4 |    you may not use this file except in compliance with the License.
 5 |    You may obtain a copy of the License at
 6 | 
 7 |        http://www.apache.org/licenses/LICENSE-2.0
 8 | 
 9 |    Unless required by applicable law or agreed to in writing, software
10 |    distributed under the License is distributed on an "AS IS" BASIS,
11 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 |    See the License for the specific language governing permissions and
13 |    limitations under the License.
14 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # fluent-plugin-forest
  2 | 
  3 | **NOTE: This plugin will not be updated: Use Fluentd v0.14 native API to handle tags.**
  4 | 
  5 | This is a plugin for [Fluentd](http://fluentd.org).
  6 | 
  7 | ## Component
  8 | 
  9 | ### ForestOutput
 10 | 
 11 | ForestOutput creates sub plugin instance of a output plugin dynamically per tag, from template configurations.
 12 | In template configurations, you can write configuration lines for overall tags by `<template>`, and for specified tags by `<case TAG_PATTERN>`, and you can use \_\_TAG\_\_ (or ${tag}) placeholder at anywhere in `<template>` and `<case>`.
 13 | 
 14 | This plugin helps you if you are writing very long configurations by copy&paste with a little little diff for many tags.
 15 | 
 16 | Other supported placeholders:
 17 | * \_\_HOSTNAME\_\_ (or ${hostname})
 18 |   * replaced with string specified by 'hostname' configuration value, or (default) result of 'hostname' command
 19 | * \_\_ESCAPED\_TAG\_\_ (or ${escaped\_tag})
 20 |   * replaced with escaped tag. Escaped tag is replaced '.' with a character specified by 'escape\_tag\_separator' (default: '\_')
 21 | * \_\_TAG_PARTS[n]\_\_ (or ${tag_parts[n]})
 22 |   * it acts accessing the index which split the tag with '.' (dot). It will get 'td' by ${tag_parts[0]}, 'apache' by ${tag_parts[1]} and 'access' by ${tag_parts[-1]} when the tag was `td.apache.access`.
 23 |   * you can also use range index like '1..4' or '1...3' (e.g. ${tag_parts[1..-1]} will return 'apache.access' on giving tag same as previous.)
 24 | 
 25 | You SHOULD NOT use ForestOutput for tags increasing infinitly. 
 26 | 
 27 | ## Configuration
 28 | 
 29 | **NOTICE:** If you configure `fluent-plugin-forest` with `buffer_type file` (or plugins, default buffer type is file), you should modify `buffer_path` with `__TAG__` (or `${tag}`) to help to use buffer files for each tags.
 30 | 
 31 | ### ForestOutput
 32 | 
 33 | If you are writing long long configurations like below:
 34 | 
 35 |     <match service.blog>
 36 |       @type file
 37 |       time_slice_format %Y%m%d%H
 38 |       compress gz
 39 |       path /var/log/blog.*.log
 40 |     </match>
 41 |     <match service.portal>
 42 |       @type file
 43 |       time_slice_format %Y%m%d%H
 44 |       compress gz
 45 |       path /var/log/portal.*.log
 46 |     </match>
 47 |     <match service.news>
 48 |       @type file
 49 |       time_slice_format %Y%m%d%H
 50 |       compress gz
 51 |       path /var/log/news.*.log
 52 |     </match>
 53 |     <match service.sns>
 54 |       @type file
 55 |       time_slice_format %Y%m%d%H
 56 |       compress gz
 57 |       path /var/log/sns.*.log
 58 |     </match>
 59 |     # ...
 60 | 
 61 | You can write configuration with ForestOutput like below:
 62 | 
 63 |     <match service.*>
 64 |       @type forest
 65 |       subtype file
 66 |       remove_prefix service
 67 |       <template>
 68 |         time_slice_format %Y%m%d%H
 69 |         compress gz
 70 |         path /var/log/${tag}.*.log
 71 |       </template>
 72 |     </match>
 73 | 
 74 | If you want to place logs /var/archive for `service.search.**` as filename with hostname, without compression, `case` directive is useful:
 75 | 
 76 |     <match service.*>
 77 |       @type forest
 78 |       subtype file
 79 |       remove_prefix service
 80 |       <template>
 81 |         time_slice_format %Y%m%d%H
 82 |       </template>
 83 |       <case search.**>
 84 |         path /var/archive/__TAG__.__HOSTNAME__.*.log
 85 |       </case>
 86 |       <case *>
 87 |         compress gz
 88 |         path /var/log/__TAG__.*.log
 89 |       </case>
 90 |     </match>
 91 | 
 92 | `case` configuration overwrites `template` configuration, so you can also write like this:
 93 | 
 94 |     <match service.*>
 95 |       @type forest
 96 |       subtype file
 97 |       remove_prefix service
 98 |       <template>
 99 |         time_slice_format %Y%m%d%H
100 |         compress gz
101 |         path /var/log/__TAG__.*.log
102 |       </template>
103 |       <case search.**>
104 |         path /var/archive/__TAG__.*.log
105 |       </case>
106 |     </match>
107 | 
108 | Version 0.2.0 or later, subsections adding/overwriting are supported. About the case below, three `<store>` subsections are defined for `search.**` pattern.
109 | 
110 |     <match service.*>
111 |       @type forest
112 |       subtype copy
113 |       <template>
114 |         <store>
115 |           @type file
116 |           path /path/to/copy1
117 |         </store>
118 |         <store>
119 |           @type file
120 |           path /path/to/copy2
121 |         </store>
122 |       </template>
123 |       <case search.**>
124 |         <store>
125 |           @type file
126 |           path /path/to/copy3
127 |         </store>
128 |       </case>
129 |     </match>
130 | 
131 | Subsections with same arguments will be overwritten. See this example:
132 | 
133 |     <match service.*>
134 |       @type forest
135 |       subtype route
136 |       <template>
137 |         <route {search,admin}.a>
138 |           add_prefix first
139 |         </route>
140 |         <route {search,admin}.b>
141 |           add_prefix second
142 |         </route>
143 |         <route {search,admin}.c>
144 |           add_prefix third
145 |         </route>
146 |         <route {search,admin}.*>
147 |           add_prefix extra
148 |         </route>
149 |       </template>
150 |       <case admin.*>
151 |         <route {search,admin}.*>
152 |           add_prefix other
153 |         </route>
154 |       </case>
155 |     </match>
156 | 
157 | In this case, `<route {search,admin}.*>` subsection will be overwritten to add prefix 'other' for tag `service.admin.*`.
158 | 
159 | ### For Configuration DSL
160 | 
161 | In DSL configurations, `case` is reserved by Ruby itself. Use `pattern` instead of `case`. `pattern` works just as same as `case`. (`v0.3.0` or later.)
162 | 
163 | ## TODO
164 | 
165 | * patches welcome!
166 | 
167 | ## Copyright
168 | 
169 | * Copyright (c) 2012- TAGOMORI Satoshi (tagomoris)
170 | * License
171 |   * Apache License, Version 2.0
172 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env rake
 2 | require "bundler/gem_tasks"
 3 | 
 4 | require 'rake/testtask'
 5 | Rake::TestTask.new(:test) do |test|
 6 |   test.libs << 'lib' << 'test'
 7 |   test.pattern = 'test/**/test_*.rb'
 8 |   test.verbose = true
 9 | end
10 | 
11 | task :default => :test
12 | 


--------------------------------------------------------------------------------
/example/file.conf:
--------------------------------------------------------------------------------
 1 | <source>
 2 |   @type dummy
 3 |   tag test.dummy
 4 |   dummy {"message":"yaaaaaaaaaaaaay"}
 5 |   rate 3
 6 | </source>
 7 | 
 8 | <match test.*>
 9 |   @type forest
10 |   subtype file
11 |   <template>
12 |     path /tmp/file_${tag}
13 |     buffer_type file
14 |     flush_interval 1s
15 |   </template>
16 | </match>
17 | 


--------------------------------------------------------------------------------
/example/sample.conf:
--------------------------------------------------------------------------------
 1 | <source>
 2 |   @type forward
 3 | </source>
 4 | 
 5 | <match test.*>
 6 |   @type forest
 7 |   subtype stdout
 8 |   <template>
 9 |     output_type ltsv
10 |   </template>
11 | </match>
12 | 


--------------------------------------------------------------------------------
/fluent-plugin-forest.gemspec:
--------------------------------------------------------------------------------
 1 | # -*- encoding: utf-8 -*-
 2 | Gem::Specification.new do |gem|
 3 |   gem.name          = "fluent-plugin-forest"
 4 |   gem.version       = "0.3.3"
 5 |   gem.authors       = ["TAGOMORI Satoshi"]
 6 |   gem.email         = ["tagomoris@gmail.com"]
 7 |   gem.description   = %q{create sub-plugin dynamically per tags, with template configuration and parameters}
 8 |   gem.summary       = %q{plugin to create output plugin instances per tags dynamically}
 9 |   gem.homepage      = "https://github.com/tagomoris/fluent-plugin-forest"
10 |   gem.license       = "Apache-2.0"
11 | 
12 |   gem.files         = `git ls-files`.split($\)
13 |   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
14 |   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
15 |   gem.require_paths = ["lib"]
16 | 
17 |   gem.add_development_dependency "rake"
18 |   gem.add_development_dependency "test-unit", "~> 3.1.7"
19 |   gem.add_runtime_dependency "fluentd"
20 | end
21 | 


--------------------------------------------------------------------------------
/lib/fluent/plugin/out_forest.rb:
--------------------------------------------------------------------------------
  1 | class Fluent::ForestOutput < Fluent::MultiOutput
  2 |   Fluent::Plugin.register_output('forest', self)
  3 | 
  4 |   config_param :subtype, :string
  5 |   config_param :remove_prefix, :string, :default => nil
  6 |   config_param :add_prefix, :string, :default => nil
  7 |   config_param :hostname, :string, :default => `hostname`.chomp
  8 |   config_param :escape_tag_separator, :string, :default => '_'
  9 | 
 10 |   attr_reader :outputs
 11 | 
 12 |   # Define `log` method for v0.10.42 or earlier
 13 |   unless method_defined?(:log)
 14 |     define_method("log") { $log }
 15 |   end
 16 | 
 17 |   def configure(conf)
 18 |     super
 19 | 
 20 |     if @remove_prefix
 21 |       @removed_prefix_string = @remove_prefix + '.'
 22 |       @removed_length = @removed_prefix_string.length
 23 |     end
 24 |     if @add_prefix
 25 |       @added_prefix_string = @add_prefix + '.'
 26 |     end
 27 | 
 28 |     @mapping = {} # tag => output
 29 |     @outputs = []
 30 |     @mutex = Mutex.new
 31 | 
 32 |     @template = nil
 33 |     @parameter = nil
 34 |     @cases = []
 35 | 
 36 |     conf.elements.each do |element|
 37 |       # read and throw away to supress unread configuration warning
 38 |       touch_recursive(element)
 39 | 
 40 |       case element.name
 41 |       when 'template'
 42 |         @template = element
 43 |       when 'case', 'pattern'
 44 |         matcher = Fluent::GlobMatchPattern.new(element.arg)
 45 |         @cases.push([matcher, element])
 46 |       end
 47 |     end
 48 | 
 49 |     self
 50 |   end
 51 | 
 52 |   def touch_recursive(e)
 53 |     e.keys.each do |k|
 54 |       e[k]
 55 |     end
 56 |     e.elements.each do |child|
 57 |       touch_recursive(child)
 58 |     end
 59 |   end
 60 | 
 61 |   def shutdown
 62 |     super
 63 |     @mapping.values.each do |output|
 64 |       output.shutdown
 65 |     end
 66 |   end
 67 | 
 68 |   def parameter(tag, e, name = 'instance', arg = '')
 69 |     tag_parts = tag.split('.')
 70 |     escaped_tag = tag.gsub('.', @escape_tag_separator)
 71 |     pairs = {}
 72 |     e.each do |k,v|
 73 |       v = v.gsub(/__TAG_PARTS\[-?[0-9]+(?:\.\.\.?-?[0-9]+)?\]__|\$\{tag_parts\[-?[0-9]+(?:\.\.\.?-?[0-9]+)?\]\}/) do |tag_parts_matched|
 74 |         matched = /\[(?<first>-?[0-9]+)(?<range_part>(?<range_type>\.\.\.?)(?<last>-?[0-9]+))?\]/.match(tag_parts_matched)
 75 |         raise "BUG: gsub regex matches but index regex does not match" unless matched
 76 | 
 77 |         if matched[:range_part]
 78 |           exclude_end = (matched[:range_type] == '...')
 79 |           range = Range.new(matched[:first].to_i, matched[:last].to_i, exclude_end)
 80 |           if tag_parts[range]
 81 |             tag_parts[range].join(".")
 82 |           else
 83 |             log.warn "out_forest: missing placeholder. tag:#{tag} placeholder:#{tag_parts_matched} conf:#{k} #{v}"
 84 |             nil
 85 |           end
 86 |         else # non range index (without range_part)
 87 |           index = matched[:first].to_i
 88 |           unless tag_parts[index]
 89 |             log.warn "out_forest: missing placeholder. tag:#{tag} placeholder:#{tag_parts_matched} conf:#{k} #{v}"
 90 |           end
 91 |           tag_parts[index]
 92 |         end
 93 |       end
 94 |       v = v.gsub('__ESCAPED_TAG__', escaped_tag).gsub('${escaped_tag}', escaped_tag)
 95 |       pairs[k] = v.gsub('__TAG__', tag).gsub('${tag}', tag).gsub('__HOSTNAME__', @hostname).gsub('${hostname}', @hostname)
 96 |     end
 97 |     elements = e.elements.map do |child|
 98 |       parameter(tag, child, child.name, child.arg)
 99 |     end
100 |     Fluent::Config::Element.new(name, arg, pairs, elements)
101 |   end
102 | 
103 |   def spec(tag)
104 |     conf = Fluent::Config::Element.new('instance', '', {}, [])
105 |     conf = parameter(tag, @template) + conf if @template # a + b -> b.merge(a) (see: fluentd/lib/fluent/config.rb)
106 |     @cases.each do |m,e|
107 |       if m.match(tag)
108 |         matched_case = parameter(tag, e)
109 | 
110 |         matched_case.elements.each { |case_child|
111 |           unless case_child.arg.empty?
112 |             conf.elements.delete_if { |conf_child|
113 |               conf_child.name == case_child.name && conf_child.arg == case_child.arg
114 |             }
115 |           end
116 |         }
117 | 
118 |         conf = matched_case + conf
119 |         break
120 |       end
121 |     end
122 |     conf
123 |   end
124 | 
125 |   def plant(tag)
126 |     output = nil
127 |     begin
128 |       @mutex.synchronize {
129 |         output = @mapping[tag]
130 |         unless output
131 |           output = Fluent::Plugin.new_output(@subtype)
132 |           output.configure(spec(tag))
133 |           output.start
134 |           output.after_start if output.respond_to?(:after_start)
135 |           @mapping[tag] = output
136 |           @outputs.push(output)
137 |         end
138 |       }
139 |       log.info "out_forest plants new output: #{@subtype} for tag '#{tag}'"
140 |     rescue Fluent::ConfigError => e
141 |       log.error "failed to configure sub output #{@subtype}: #{e.message}"
142 |       log.error e.backtrace.join("\n")
143 |       log.error "Cannot output messages with tag '#{tag}'"
144 |       output = nil
145 |     rescue StandardError, ScriptError => e
146 |       log.error "failed to configure/start sub output #{@subtype}: #{e.message}"
147 |       log.error e.backtrace.join("\n")
148 |       log.error "Cannot output messages with tag '#{tag}'"
149 |       output = nil
150 |     end
151 |     output
152 |   end
153 | 
154 |   def emit(tag, es, chain)
155 |     if @remove_prefix and
156 |         ( (tag.start_with?(@removed_prefix_string) and tag.length > @removed_length) or tag == @remove_prefix)
157 |       tag = tag[@removed_length..-1]
158 |     end
159 |     if @add_prefix
160 |       tag = if tag.length > 0
161 |               @added_prefix_string + tag
162 |             else
163 |               @add_prefix
164 |             end
165 |     end
166 | 
167 |     output = @mapping[tag]
168 |     unless output
169 |       output = plant(tag)
170 |     end
171 |     if output
172 |       if output.respond_to?(:emit_events)
173 |         output.emit_events(tag, es)
174 |       else
175 |         output.emit(tag, es, chain)
176 |       end
177 |       chain.next
178 |     else # cannot plant an output (configuration error, or ...?)
179 |       chain.next
180 |     end
181 |   end
182 | end
183 | 


--------------------------------------------------------------------------------
/test/helper.rb:
--------------------------------------------------------------------------------
 1 | require 'rubygems'
 2 | require 'bundler'
 3 | begin
 4 |   Bundler.setup(:default, :development)
 5 | rescue Bundler::BundlerError => e
 6 |   $stderr.puts e.message
 7 |   $stderr.puts "Run `bundle install` to install missing gems"
 8 |   exit e.status_code
 9 | end
10 | require 'test/unit'
11 | 
12 | $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
13 | $LOAD_PATH.unshift(File.dirname(__FILE__))
14 | require 'fluent/test'
15 | unless ENV.has_key?('VERBOSE')
16 |   nulllogger = Object.new
17 |   nulllogger.instance_eval {|obj|
18 |     def method_missing(method, *args)
19 |       # pass
20 |     end
21 |   }
22 |   $log = nulllogger
23 | end
24 | 
25 | require 'fluent/plugin/out_forest'
26 | 
27 | class Test::Unit::TestCase
28 | end
29 | 


--------------------------------------------------------------------------------
/test/output/out_forest_test.rb:
--------------------------------------------------------------------------------
 1 | class Fluent::ForestTestOutput < Fluent::Output
 2 |   Fluent::Plugin.register_output('forest_test', self)
 3 | 
 4 |   config_param :key_name, :string, :default => 'msg'
 5 |   config_param :tag
 6 |   config_param :prefix, :string, :default => ''
 7 |   config_param :suffix, :string, :default => ''
 8 |   config_param :tagfield, :string, :default => nil
 9 | 
10 |   attr_accessor :started, :stopped
11 | 
12 |   def configure(conf)
13 |     super
14 | 
15 |     if @tag == 'raise.error'
16 |       raise Fluent::ConfigError, "specified to raise.error"
17 |     end
18 |   end
19 | 
20 |   def start
21 |     super
22 |     @started = true
23 |   end
24 | 
25 |   def shutdown
26 |     super
27 |     @stopped = true
28 |   end
29 | 
30 |   def emit(tag, es, chain)
31 |     es.each {|time, record|
32 |       r = record.merge({@key_name => @prefix + record[@key_name] + @suffix})
33 |       unless @started
34 |         r = r.merge({'not_started' => true})
35 |       end
36 |       if @tagfield
37 |         r[@tagfield] = tag
38 |       end
39 |       router.emit(@tag, time, r)
40 |     }
41 |     chain.next
42 |   end
43 | end
44 | 


--------------------------------------------------------------------------------
/test/plugin/test_out_forest.rb:
--------------------------------------------------------------------------------
  1 | require 'helper'
  2 | require_relative '../output/out_forest_test'
  3 | 
  4 | class ForestOutputTest < Test::Unit::TestCase
  5 |   def setup
  6 |     Fluent::Test.setup
  7 |   end
  8 | 
  9 |   CONFIG = %[
 10 | subtype forest_test
 11 | remove_prefix test
 12 | <template>
 13 |   key_name f
 14 |   suffix !
 15 |   tag out.__TAG__
 16 | </template>
 17 | <case foo.bar>
 18 |   prefix p1:
 19 | </case>
 20 | <case foo.*>
 21 |   prefix p2:
 22 | </case>
 23 | <case bar.**>
 24 |   prefix p3:
 25 | </case>
 26 | <case *>
 27 |   prefix p4:
 28 | </case>
 29 |   ]
 30 | 
 31 |   def create_driver(conf = CONFIG, tag='test.default')
 32 |     Fluent::Test::OutputTestDriver.new(Fluent::ForestOutput, tag).configure(conf)
 33 |   end
 34 | 
 35 |   def test_configure
 36 |     assert_nothing_raised { d = create_driver }
 37 |   end
 38 | 
 39 |   def test_spec
 40 |     d = create_driver %[
 41 | subtype hoge
 42 | <template>
 43 |   keyx xxxxxx
 44 |   keyy yyyyyy.__TAG__
 45 |   alt_key a
 46 | </template>
 47 | <case xx>
 48 |   keyz z1
 49 |   alt_key b
 50 | </case>
 51 | <case yy.**>
 52 |   keyz z2
 53 |   alt_key c
 54 | </case>
 55 | <case *>
 56 |   keyz z3
 57 |   alt_key d.__TAG__
 58 | </case>
 59 |     ]
 60 |     conf = d.instance.spec('xx')
 61 |     assert_equal 'xxxxxx', conf['keyx']
 62 |     assert_equal 'yyyyyy.xx', conf['keyy']
 63 |     assert_equal 'z1', conf['keyz']
 64 |     assert_equal 'b', conf['alt_key']
 65 | 
 66 |     conf = d.instance.spec('yy')
 67 |     assert_equal 'xxxxxx', conf['keyx']
 68 |     assert_equal 'yyyyyy.yy', conf['keyy']
 69 |     assert_equal 'z2', conf['keyz']
 70 |     assert_equal 'c', conf['alt_key']
 71 | 
 72 |     conf = d.instance.spec('yy.3')
 73 |     assert_equal 'xxxxxx', conf['keyx']
 74 |     assert_equal 'yyyyyy.yy.3', conf['keyy']
 75 |     assert_equal 'z2', conf['keyz']
 76 |     assert_equal 'c', conf['alt_key']
 77 | 
 78 |     conf = d.instance.spec('zz')
 79 |     assert_equal 'xxxxxx', conf['keyx']
 80 |     assert_equal 'yyyyyy.zz', conf['keyy']
 81 |     assert_equal 'z3', conf['keyz']
 82 |     assert_equal 'd.zz', conf['alt_key']
 83 |   end
 84 | 
 85 |   def test_spec_with_pattern_section
 86 |     d = create_driver %[
 87 | subtype hoge
 88 | <template>
 89 |   keyx xxxxxx
 90 |   keyy yyyyyy.__TAG__
 91 |   alt_key a
 92 | </template>
 93 | <pattern xx>
 94 |   keyz z1
 95 |   alt_key b
 96 | </pattern>
 97 | <pattern yy.**>
 98 |   keyz z2
 99 |   alt_key c
100 | </pattern>
101 | <pattern *>
102 |   keyz z3
103 |   alt_key d.__TAG__
104 | </pattern>
105 |     ]
106 |     conf = d.instance.spec('xx')
107 |     assert_equal 'xxxxxx', conf['keyx']
108 |     assert_equal 'yyyyyy.xx', conf['keyy']
109 |     assert_equal 'z1', conf['keyz']
110 |     assert_equal 'b', conf['alt_key']
111 | 
112 |     conf = d.instance.spec('yy')
113 |     assert_equal 'xxxxxx', conf['keyx']
114 |     assert_equal 'yyyyyy.yy', conf['keyy']
115 |     assert_equal 'z2', conf['keyz']
116 |     assert_equal 'c', conf['alt_key']
117 | 
118 |     conf = d.instance.spec('yy.3')
119 |     assert_equal 'xxxxxx', conf['keyx']
120 |     assert_equal 'yyyyyy.yy.3', conf['keyy']
121 |     assert_equal 'z2', conf['keyz']
122 |     assert_equal 'c', conf['alt_key']
123 | 
124 |     conf = d.instance.spec('zz')
125 |     assert_equal 'xxxxxx', conf['keyx']
126 |     assert_equal 'yyyyyy.zz', conf['keyy']
127 |     assert_equal 'z3', conf['keyz']
128 |     assert_equal 'd.zz', conf['alt_key']
129 |   end
130 | 
131 |   NESTED_CONF = %[
132 | subtype hoge
133 | <template>
134 |   keyx xxxxxx
135 |   keyy yyyyyy.__TAG__
136 |   alt_key a
137 |   <tagx>
138 |     key xxx
139 |   </tagx>
140 |   <tagy>
141 |     key yyy.__TAG__
142 |   </tagy>
143 |   <tag_with attr.foo>
144 |     key bar
145 |   </tag_with>
146 |   <tag_with attr.foo>
147 |     key dup
148 |   </tag_with>
149 |   <tag_with attr.foo>
150 |     key dupdup
151 |   </tag_with>
152 | </template>
153 | <case xx>
154 |   keyz z1
155 |   alt_key b
156 | </case>
157 | <case yy.**>
158 |   keyz z2
159 |   alt_key c
160 |   <tagx>
161 |     key not_overwrite
162 |   </tagx>
163 |   <tag_with attr.foo>
164 |     key overwrite
165 |   </tag_with>
166 |   <tag_with attr.foo>
167 |     key overwrite_dup
168 |   </tag_with>
169 | </case>
170 | <case *>
171 |   keyz z3
172 |   alt_key d.__TAG__
173 |   <tagz>
174 |     <tagw>
175 |       key www
176 |     </tagw>
177 |   </tagz>
178 |   <tag_with attr.*>
179 |     key not_overwrite
180 |   </tag_with>
181 | </case>
182 |     ]
183 | 
184 |   def test_spec_nested_overwrite_attributes_only
185 |     d = create_driver NESTED_CONF
186 |     conf = d.instance.spec('xx')
187 |     assert_equal 'xxxxxx', conf['keyx']
188 |     assert_equal 'yyyyyy.xx', conf['keyy']
189 |     assert_equal 'z1', conf['keyz']
190 |     assert_equal 'b', conf['alt_key']
191 | 
192 |     assert_equal 5, conf.elements.size
193 | 
194 |     assert_equal 'tagx', conf.elements[0].name
195 |     assert_equal 'xxx', conf.elements[0]['key']
196 | 
197 |     assert_equal 'tagy', conf.elements[1].name
198 |     assert_equal 'yyy.xx', conf.elements[1]['key']
199 | 
200 |     assert_equal 'tag_with', conf.elements[2].name
201 |     assert_equal 'attr.foo', conf.elements[2].arg
202 |     assert_equal 'bar', conf.elements[2]['key']
203 | 
204 |     assert_equal 'tag_with', conf.elements[3].name
205 |     assert_equal 'attr.foo', conf.elements[3].arg
206 |     assert_equal 'dup', conf.elements[3]['key']
207 | 
208 |     assert_equal 'tag_with', conf.elements[4].name
209 |     assert_equal 'attr.foo', conf.elements[4].arg
210 |     assert_equal 'dupdup', conf.elements[4]['key']
211 |   end
212 |   def test_spec_nested_overwrite_subsections_with_arg
213 |     d = create_driver NESTED_CONF
214 |     conf = d.instance.spec('yy')
215 | 
216 |     assert_equal 'xxxxxx', conf['keyx']
217 |     assert_equal 'yyyyyy.yy', conf['keyy']
218 |     assert_equal 'z2', conf['keyz']
219 |     assert_equal 'c', conf['alt_key']
220 | 
221 |     assert_equal 5, conf.elements.size
222 | 
223 |     assert_equal 'tagx', conf.elements[0].name
224 |     assert_equal 'not_overwrite', conf.elements[0]['key']
225 | 
226 |     assert_equal 'tag_with', conf.elements[1].name
227 |     assert_equal 'attr.foo', conf.elements[1].arg
228 |     assert_equal 'overwrite', conf.elements[1]['key']
229 | 
230 |     assert_equal 'tag_with', conf.elements[2].name
231 |     assert_equal 'attr.foo', conf.elements[2].arg
232 |     assert_equal 'overwrite_dup', conf.elements[2]['key']
233 | 
234 |     assert_equal 'tagx', conf.elements[3].name
235 |     assert_equal 'xxx', conf.elements[3]['key']
236 | 
237 |     assert_equal 'tagy', conf.elements[4].name
238 |     assert_equal 'yyy.yy', conf.elements[4]['key']
239 |   end
240 | 
241 |   def test_spec_nested_subsections_added
242 |     d = create_driver NESTED_CONF
243 |     conf = d.instance.spec('zz')
244 | 
245 |     assert_equal 'xxxxxx', conf['keyx']
246 |     assert_equal 'yyyyyy.zz', conf['keyy']
247 |     assert_equal 'z3', conf['keyz']
248 |     assert_equal 'd.zz', conf['alt_key']
249 | 
250 |     assert_equal 7, conf.elements.size
251 | 
252 |     assert_equal 'tagz', conf.elements[0].name
253 |     assert_equal 1, conf.elements[0].elements.size
254 |     assert_equal 'tagw', conf.elements[0].elements[0].name
255 |     assert_equal 'www', conf.elements[0].elements[0]['key']
256 | 
257 |     assert_equal 'tag_with', conf.elements[1].name
258 |     assert_equal 'attr.*', conf.elements[1].arg
259 |     assert_equal 'not_overwrite', conf.elements[1]['key']
260 | 
261 |     assert_equal 'tagx', conf.elements[2].name
262 |     assert_equal 'xxx', conf.elements[2]['key']
263 | 
264 |     assert_equal 'tagy', conf.elements[3].name
265 |     assert_equal 'yyy.zz', conf.elements[3]['key']
266 | 
267 |     assert_equal 'tag_with', conf.elements[4].name
268 |     assert_equal 'attr.foo', conf.elements[4].arg
269 |     assert_equal 'bar', conf.elements[4]['key']
270 | 
271 |     assert_equal 'tag_with', conf.elements[5].name
272 |     assert_equal 'attr.foo', conf.elements[5].arg
273 |     assert_equal 'dup', conf.elements[5]['key']
274 | 
275 |     assert_equal 'tag_with', conf.elements[6].name
276 |     assert_equal 'attr.foo', conf.elements[6].arg
277 |     assert_equal 'dupdup', conf.elements[6]['key']
278 |   end
279 | 
280 |   def test_spec_replace_tag_separator
281 |     d = create_driver %[
282 | subtype hoge
283 | <template>
284 |   keyx xxxxxx
285 |   keyy yyyyyy.__ESCAPED_TAG__
286 | </template>
287 | <case xx.*>
288 |   keyz zzzzzz.__ESCAPED_TAG__
289 |   alt_key a
290 | </case>
291 | <case xx.**>
292 |   keyz zzzzzz.${escaped_tag}
293 |   alt_key b
294 | </case>
295 |     ]
296 | 
297 |     conf = d.instance.spec('xx.1')
298 |     assert_equal 'xxxxxx', conf['keyx']
299 |     assert_equal 'yyyyyy.xx_1', conf['keyy']
300 |     assert_equal 'zzzzzz.xx_1', conf['keyz']
301 |     assert_equal 'a', conf['alt_key']
302 | 
303 |     conf = d.instance.spec('xx.1.2')
304 |     assert_equal 'xxxxxx', conf['keyx']
305 |     assert_equal 'yyyyyy.xx_1_2', conf['keyy']
306 |     assert_equal 'zzzzzz.xx_1_2', conf['keyz']
307 |     assert_equal 'b', conf['alt_key']
308 |   end
309 | 
310 |   def test_spec_replace_tag_separator_with_specified_char
311 |     d = create_driver %[
312 | subtype hoge
313 | escape_tag_separator +
314 | <template>
315 |   keyx xxxxxx
316 |   keyy yyyyyy.__ESCAPED_TAG__
317 | </template>
318 | <case xx.**>
319 |   keyz zzzzzz.${escaped_tag}
320 | </case>
321 |     ]
322 | 
323 |     conf = d.instance.spec('xx.1')
324 |     assert_equal 'xxxxxx', conf['keyx']
325 |     assert_equal 'yyyyyy.xx+1', conf['keyy']
326 |     assert_equal 'zzzzzz.xx+1', conf['keyz']
327 | 
328 |     conf = d.instance.spec('xx.1.2')
329 |     assert_equal 'xxxxxx', conf['keyx']
330 |     assert_equal 'yyyyyy.xx+1+2', conf['keyy']
331 |     assert_equal 'zzzzzz.xx+1+2', conf['keyz']
332 |   end
333 | 
334 |   def test_spec_split_tag_by_dot_with_int_index
335 |     d = create_driver %[
336 | subtype hoge
337 | <template>
338 |   keya aaaaaa
339 |   keyb bbbbbb.${tag_parts[0]}
340 |   unknown_tag_parts bar${tag_parts[999]}__TAG_PARTS[999]__
341 | </template>
342 | <case xx.*>
343 |   keyc cccccc.${tag_parts[0]}.${tag_parts[1]}
344 |   keyd dddddd.${tag_parts[-2]}.${tag_parts[-1]}
345 |   alt_key a
346 | </case>
347 | <case xx.**>
348 |   keyc cccccc.__TAG_PARTS[0]__.__TAG_PARTS[2]__
349 |   keyd dddddd.__TAG_PARTS[-2]__.__TAG_PARTS[-1]__
350 |   alt_key b
351 | </case>
352 |     ]
353 | 
354 |     conf = d.instance.spec('xx.1')
355 |     assert_equal 'aaaaaa', conf['keya']
356 |     assert_equal 'bbbbbb.xx', conf['keyb']
357 |     assert_equal 'cccccc.xx.1', conf['keyc']
358 |     assert_equal 'dddddd.xx.1', conf['keyd']
359 |     assert_equal 'bar', conf['unknown_tag_parts']
360 |     assert_equal 'a', conf['alt_key']
361 | 
362 |     conf = d.instance.spec('xx.1.2')
363 |     assert_equal 'aaaaaa', conf['keya']
364 |     assert_equal 'bbbbbb.xx', conf['keyb']
365 |     assert_equal 'cccccc.xx.2', conf['keyc']
366 |     assert_equal 'dddddd.1.2', conf['keyd']
367 |     assert_equal 'b', conf['alt_key']
368 |   end
369 | 
370 |   def test_spec_split_tag_by_dot_with_range_index
371 |     d = create_driver %[
372 | subtype hoge
373 | <template>
374 |   keya aaaaaa
375 |   keyb bbbbbb.${tag_parts[0]}
376 |   unknown_tag_parts bar${tag_parts[999..1000]}__TAG_PARTS[999...1001]__
377 | </template>
378 | <case xx.*>
379 |   keyc cccccc.${tag_parts[0..1]}
380 |   keyd dddddd.${tag_parts[-2..-1]}
381 |   keye eeeeee.${tag_parts[1..1000]}
382 |   alt_key a
383 | </case>
384 | <case xx.**>
385 |   keyc cccccc.__TAG_PARTS[1...3]__
386 |   keyd dddddd.__TAG_PARTS[-3...-1]__
387 |   keye eeeeee.__TAG_PARTS[1...1000]__
388 |   alt_key b
389 | </case>
390 |     ]
391 | 
392 |     conf = d.instance.spec('xx.1')
393 |     assert_equal 'aaaaaa', conf['keya']
394 |     assert_equal 'bbbbbb.xx', conf['keyb']
395 |     assert_equal 'cccccc.xx.1', conf['keyc']
396 |     assert_equal 'dddddd.xx.1', conf['keyd']
397 |     assert_equal 'eeeeee.1', conf['keye']
398 |     assert_equal 'bar', conf['unknown_tag_parts']
399 |     assert_equal 'a', conf['alt_key']
400 | 
401 |     conf = d.instance.spec('xx.1.2')
402 |     assert_equal 'aaaaaa', conf['keya']
403 |     assert_equal 'bbbbbb.xx', conf['keyb']
404 |     assert_equal 'cccccc.1.2', conf['keyc']
405 |     assert_equal 'dddddd.xx.1', conf['keyd']
406 |     assert_equal 'eeeeee.1.2', conf['keye']
407 |     assert_equal 'b', conf['alt_key']
408 |   end
409 | 
410 |   def test_spec_hostname
411 |     d = create_driver %[
412 | subtype hoge
413 | hostname somehost.local
414 | <template>
415 |   keyx xxxxxx.__HOSTNAME__
416 |   keyy yyyyyy.__TAG__
417 |   alt_key a
418 | </template>
419 | <case xx>
420 |   keyz z1
421 |   alt_key b
422 | </case>
423 | <case yy.**>
424 |   keyz z2
425 |   alt_key c
426 | </case>
427 | <case *>
428 |   keyz z3
429 |   alt_key d.__TAG__.__HOSTNAME__
430 | </case>
431 |     ]
432 |     conf = d.instance.spec('xx')
433 |     assert_equal 'xxxxxx.somehost.local', conf['keyx']
434 |     assert_equal 'yyyyyy.xx', conf['keyy']
435 |     assert_equal 'z1', conf['keyz']
436 |     assert_equal 'b', conf['alt_key']
437 | 
438 |     conf = d.instance.spec('yy')
439 |     assert_equal 'xxxxxx.somehost.local', conf['keyx']
440 |     assert_equal 'yyyyyy.yy', conf['keyy']
441 |     assert_equal 'z2', conf['keyz']
442 |     assert_equal 'c', conf['alt_key']
443 | 
444 |     conf = d.instance.spec('yy.3')
445 |     assert_equal 'xxxxxx.somehost.local', conf['keyx']
446 |     assert_equal 'yyyyyy.yy.3', conf['keyy']
447 |     assert_equal 'z2', conf['keyz']
448 |     assert_equal 'c', conf['alt_key']
449 | 
450 |     conf = d.instance.spec('zz')
451 |     assert_equal 'xxxxxx.somehost.local', conf['keyx']
452 |     assert_equal 'yyyyyy.zz', conf['keyy']
453 |     assert_equal 'z3', conf['keyz']
454 |     assert_equal 'd.zz.somehost.local', conf['alt_key']
455 |   end
456 | 
457 |   def test_spec_real_hostname
458 |     hostname = `hostname`.chomp
459 |     d = create_driver %[
460 | subtype hoge
461 | <template>
462 |   keyx xxxxxx.__HOSTNAME__
463 |   keyy yyyyyy.__TAG__
464 |   alt_key a
465 | </template>
466 | <case xx>
467 |   keyz z1
468 |   alt_key b
469 | </case>
470 | <case yy.**>
471 |   keyz z2
472 |   alt_key c
473 | </case>
474 | <case *>
475 |   keyz z3
476 |   alt_key d.${tag}.${hostname}
477 | </case>
478 |     ]
479 |     conf = d.instance.spec('xx')
480 |     assert_equal 'xxxxxx.' + hostname, conf['keyx']
481 |     assert_equal 'yyyyyy.xx', conf['keyy']
482 |     assert_equal 'z1', conf['keyz']
483 |     assert_equal 'b', conf['alt_key']
484 | 
485 |     conf = d.instance.spec('yy')
486 |     assert_equal 'xxxxxx.' + hostname, conf['keyx']
487 |     assert_equal 'yyyyyy.yy', conf['keyy']
488 |     assert_equal 'z2', conf['keyz']
489 |     assert_equal 'c', conf['alt_key']
490 | 
491 |     conf = d.instance.spec('yy.3')
492 |     assert_equal 'xxxxxx.' + hostname, conf['keyx']
493 |     assert_equal 'yyyyyy.yy.3', conf['keyy']
494 |     assert_equal 'z2', conf['keyz']
495 |     assert_equal 'c', conf['alt_key']
496 | 
497 |     conf = d.instance.spec('zz')
498 |     assert_equal 'xxxxxx.' + hostname, conf['keyx']
499 |     assert_equal 'yyyyyy.zz', conf['keyy']
500 |     assert_equal 'z3', conf['keyz']
501 |     assert_equal 'd.zz.' + hostname, conf['alt_key']
502 |   end
503 | 
504 |   def test_faild_plant
505 |     d = create_driver
506 |     time = Time.parse("2012-01-02 13:14:15").to_i
507 |     d.tag = 'test.xxxxxx';  d.run { d.emit({'f' => "message 1"}, time) }
508 |     emits = d.emits
509 |     assert_equal 1, emits.length
510 | 
511 |     d = create_driver %[
512 | subtype forest_test
513 | remove_prefix test
514 | <template>
515 |   key_name f
516 |   suffix !
517 |   tag __TAG__
518 | </template>
519 | <case foo.bar>
520 |   prefix p1:
521 | </case>
522 | <case foo.*>
523 |   prefix p2:
524 | </case>
525 | <case bar.**>
526 |   prefix p3:
527 | </case>
528 | <case *>
529 |   prefix p4:
530 | </case>
531 |     ]
532 |     time = Time.parse("2012-01-02 13:14:15").to_i
533 |     d.tag = 'test.raise.error';  d.run { d.emit({'f' => "message 1"}, time) }
534 |     emits = d.emits
535 |     assert_equal 0, emits.length
536 |   end
537 | 
538 |   def test_emit
539 |     d = create_driver
540 |     time = Time.parse("2012-01-02 13:14:15").to_i
541 |     d.tag = 'test.first';  d.run { d.emit({'f' => "message 1"}, time) }
542 |     d.tag = 'test.second'; d.run { d.emit({'f' => "message 2"}, time) }
543 |     d.tag = 'test.foo.bar'; d.run { d.emit({'f' => "message 3"}, time) }
544 |     d.tag = 'test.foo.baz'; d.run { d.emit({'f' => "message 4"}, time) }
545 |     d.tag = 'test.bar';     d.run { d.emit({'f' => "message 5"}, time) }
546 |     d.tag = 'test.baz';     d.run { d.emit({'f' => "message 6"}, time) }
547 |     d.tag = 'test.foo.bar'; d.run { d.emit({'f' => "message 7"}, time) }
548 |     d.tag = 'test.bar';     d.run { d.emit({'f' => "message 8"}, time) }
549 | 
550 |     emits = d.emits
551 | 
552 |     e = emits[0]
553 |     assert_equal 'out.first', e[0]
554 |     assert_equal time, e[1]
555 |     assert_equal "p4:message 1!", e[2]['f']
556 |     assert_nil e[2]['not_started']
557 | 
558 |     e = emits[1]
559 |     assert_equal 'out.second', e[0]
560 |     assert_equal time, e[1]
561 |     assert_equal "p4:message 2!", e[2]['f']
562 |     assert_nil e[2]['not_started']
563 | 
564 |     e = emits[2]
565 |     assert_equal 'out.foo.bar', e[0]
566 |     assert_equal time, e[1]
567 |     assert_equal "p1:message 3!", e[2]['f']
568 |     assert_nil e[2]['not_started']
569 | 
570 |     e = emits[3]
571 |     assert_equal 'out.foo.baz', e[0]
572 |     assert_equal time, e[1]
573 |     assert_equal "p2:message 4!", e[2]['f']
574 |     assert_nil e[2]['not_started']
575 | 
576 |     e = emits[4]
577 |     assert_equal 'out.bar', e[0]
578 |     assert_equal time, e[1]
579 |     assert_equal "p3:message 5!", e[2]['f']
580 |     assert_nil e[2]['not_started']
581 | 
582 |     e = emits[5]
583 |     assert_equal 'out.baz', e[0]
584 |     assert_equal time, e[1]
585 |     assert_equal "p4:message 6!", e[2]['f']
586 |     assert_nil e[2]['not_started']
587 | 
588 |     e = emits[6]
589 |     assert_equal 'out.foo.bar', e[0]
590 |     assert_equal time, e[1]
591 |     assert_equal "p1:message 7!", e[2]['f']
592 |     assert_nil e[2]['not_started']
593 | 
594 |     e = emits[7]
595 |     assert_equal 'out.bar', e[0]
596 |     assert_equal time, e[1]
597 |     assert_equal "p3:message 8!", e[2]['f']
598 |     assert_nil e[2]['not_started']
599 |   end
600 | end
601 | 


--------------------------------------------------------------------------------
/test/plugin/test_out_forest_test.rb:
--------------------------------------------------------------------------------
  1 | require 'helper'
  2 | require_relative '../output/out_forest_test'
  3 | 
  4 | class ForestTestOutputTest < Test::Unit::TestCase
  5 |   def setup
  6 |     Fluent::Test.setup
  7 |   end
  8 | 
  9 |   CONFIG = %[
 10 | tag foo.bar
 11 | tagfield ttt
 12 | prefix fixed:
 13 | suffix :end
 14 |   ]
 15 | 
 16 |   def create_driver(conf = CONFIG, tag='test')
 17 |     Fluent::Test::OutputTestDriver.new(Fluent::ForestTestOutput, tag).configure(conf)
 18 |   end
 19 | 
 20 |   def test_configure
 21 |     d = create_driver
 22 |     assert_equal 'foo.bar', d.instance.tag
 23 |     assert_equal 'fixed:', d.instance.prefix
 24 |     assert_equal ':end', d.instance.suffix
 25 |   end
 26 | 
 27 |   def test_emit
 28 |     d = create_driver
 29 |     time = Time.parse("2012-01-02 13:14:15").to_i
 30 |     d.run do
 31 |       d.emit({'msg' => 'xyz 123', 'alt' => 'aaa bbb ccc'}, time)
 32 |       d.emit({'msg' => 'xyz 456', 'alt' => 'aaa bbb ccc ddd'}, time)
 33 |     end
 34 |     emits = d.emits
 35 |     assert_equal 2, emits.length
 36 | 
 37 |     assert_equal 'foo.bar', emits[0][0]
 38 |     assert_equal time, emits[0][1]
 39 |     assert_equal 'fixed:xyz 123:end', emits[0][2]['msg']
 40 |     assert_equal 'aaa bbb ccc', emits[0][2]['alt']
 41 |     assert_equal 'test', emits[0][2]['ttt']
 42 | 
 43 |     assert_equal 'foo.bar', emits[1][0]
 44 |     assert_equal time, emits[1][1]
 45 |     assert_equal 'fixed:xyz 456:end', emits[1][2]['msg']
 46 |     assert_equal 'aaa bbb ccc ddd', emits[1][2]['alt']
 47 |     assert_equal 'test', emits[1][2]['ttt']
 48 |   end
 49 | 
 50 |   def test_emit1
 51 |     d = create_driver
 52 |     time = Time.parse("2012-01-02 13:14:15").to_i
 53 |     d.run do
 54 |       d.emit({'msg' => 'xyz 123', 'alt' => 'aaa bbb ccc'}, time)
 55 |       d.tag = 'test2'
 56 |       d.emit({'msg' => 'xyz 456', 'alt' => 'aaa bbb ccc ddd'}, time)
 57 |     end
 58 |     emits = d.emits
 59 |     assert_equal 2, emits.length
 60 | 
 61 |     assert_equal 'foo.bar', emits[0][0]
 62 |     assert_equal time, emits[0][1]
 63 |     assert_equal 'fixed:xyz 123:end', emits[0][2]['msg']
 64 |     assert_equal 'aaa bbb ccc', emits[0][2]['alt']
 65 |     assert_equal 'test', emits[0][2]['ttt']
 66 |     assert_nil emits[0][2]['not_started']
 67 | 
 68 |     assert_equal 'foo.bar', emits[1][0]
 69 |     assert_equal time, emits[1][1]
 70 |     assert_equal 'fixed:xyz 456:end', emits[1][2]['msg']
 71 |     assert_equal 'aaa bbb ccc ddd', emits[1][2]['alt']
 72 |     assert_equal 'test2', emits[1][2]['ttt']
 73 |     assert_nil emits[1][2]['not_started']
 74 |   end
 75 | 
 76 |   def test_emit2
 77 |     d = create_driver
 78 |     time = Time.parse("2012-01-02 13:14:15").to_i
 79 |     d.run do
 80 |       d.emit({'msg' => 'xyz 123', 'alt' => 'aaa bbb ccc'}, time)
 81 |     end
 82 |     d.tag = 'test2'
 83 |     d.run do
 84 |       d.emit({'msg' => 'xyz 456', 'alt' => 'aaa bbb ccc ddd'}, time)
 85 |     end
 86 |     emits = d.emits
 87 |     assert_equal 2, emits.length
 88 | 
 89 |     assert_equal 'foo.bar', emits[0][0]
 90 |     assert_equal time, emits[0][1]
 91 |     assert_equal 'fixed:xyz 123:end', emits[0][2]['msg']
 92 |     assert_equal 'aaa bbb ccc', emits[0][2]['alt']
 93 |     assert_equal 'test', emits[0][2]['ttt']
 94 |     assert_nil emits[0][2]['not_started']
 95 | 
 96 |     assert_equal 'foo.bar', emits[1][0]
 97 |     assert_equal time, emits[1][1]
 98 |     assert_equal 'fixed:xyz 456:end', emits[1][2]['msg']
 99 |     assert_equal 'aaa bbb ccc ddd', emits[1][2]['alt']
100 |     assert_equal 'test2', emits[1][2]['ttt']
101 |     assert_nil emits[1][2]['not_started']
102 |   end
103 | end
104 | 


--------------------------------------------------------------------------------