fluent-plugin-norikra 0.0.1

data/lib/fluent/plugin/out_norikra.rb

@@ -0,0 +1,388 @@
+module Fluent
+  class NorikraOutput < Fluent::BufferedOutput
+    Fluent::Plugin.register_output('norikra', self)
+
+    config_set_default :flush_interval, 1 # 1sec
+
+    config_param :norikra, :string, :default => 'localhost:26571'
+
+    config_param :connect_timeout, :integer, :default => nil
+    config_param :send_timeout, :integer, :default => nil
+    config_param :receive_timeout, :integer, :default => nil
+
+    #<server>
+    attr_reader :execute_server, :execute_server_path
+
+    config_param :remove_tag_prefix, :string, :default => nil
+
+    config_param :target_map_tag, :bool, :default => false
+    config_param :target_map_key, :string, :default => nil
+    config_param :target_string, :string, :default => nil
+
+    # <default>
+    # <target TARGET>
+
+    # <events>
+    attr_reader :event_method, :event_tag_generator, :event_sweep_interval
+
+    def initialize
+      super
+      require_relative 'norikra_target'
+      require 'norikra/client'
+    end
+
+    def configure(conf)
+      super
+
+      @host,@port = @norikra.split(':', 2)
+      @port = @port.to_i
+
+      if !@target_map_tag && @target_map_key.nil? && @target_string.nil?
+        raise Fluent::ConfigError, 'target naming not specified (target_map_tag/target_map_key/target_string)'
+      end
+      @target_generator = case
+                          when @target_string
+                            lambda {|tag,record| @target_string}
+                          when @target_map_key
+                            lambda {|tag,record| record[@target_map_key]}
+                          when @target_map_tag
+                            lambda {|tag,record| tag.gsub(/^#{@remove_tag_prefix}(\.)?/, '')}
+                          else
+                            raise Fluent::ConfigError, "no one way specified to decide target"
+                          end
+
+      # target map already prepared (opened, and related queries registered)
+      @target_map = {} # 'target' => instance of Fluent::NorikraOutput::Target
+
+      # for conversion from query_name to tag
+      @query_map = {} # 'query_name' => instance of Fluent::NorikraOutput::Query
+
+      @default_target = ConfigSection.new(Fluent::Config::Element.new('default', nil, {}, []))
+      @config_targets = {}
+
+      @execute_server = false
+
+      event_section = nil
+      conf.elements.each do |element|
+        case element.name
+        when 'default'
+          @default_target = ConfigSection.new(element)
+        when 'target'
+          c = ConfigSection.new(element)
+          @config_targets[c.target] = c
+        when 'server'
+          @execute_server = Fluent::Config.bool_value(element['execute'])
+          @execute_server_path = element['path']
+        when 'event'
+          event_section = element
+        else
+          raise Fluent::ConfigError, "unknown configuration section name for this plugin: #{element.name}"
+        end
+      end
+
+      @event_method = @event_tag_generator = @event_sweep_interval = nil
+      if event_section
+        @event_method = case event_section['method']
+                        when 'sweep' then :sweep
+                        when 'listen'
+                          raise Fluent::ConfigError, "not implemeneted now"
+                        else
+                          raise Fluent::ConfigError, "unknown method #{event_section['method']}"
+                        end
+        unless event_section['tag']
+          raise Fluent::ConfigError, "<event> section needs 'tag' configuration"
+        end
+        tag_prefix = if event_section.has_key?('tag_prefix')
+                       event_section['tag_prefix'] + (event_section['tag_prefix'] =~ /\.$/ ? '' : '.')
+                     else
+                       ''
+                     end
+        tag_by, tag_arg = event_section['tag'].split(/ +/, 2)
+        @event_tag_generator = case tag_by
+                               when 'query_name' then lambda{|query_name,record| tag_prefix + query_name}
+                               when 'field' then lambda{|query_name,record| tag_prefix + record[tag_arg]}
+                               when 'string' then lambda{|query_name,record| tag_prefix + tag_arg}
+                               else
+                                 raise Fluent::ConfigError, "unknown tag configuration specified:#{event_section['tag']}"
+                               end
+        @event_sweep_interval = Fluent::Config.time_value(event_section['sweep_interval'] || '10s')
+      end
+
+      @mutex = Mutex.new
+    end
+
+    def client(opts={})
+      Norikra::Client.new(@host, @port, {
+          :connect_timeout => opts[:connect_timeout] || @connect_timeout,
+          :send_timeout    => opts[:send_timeout]    || @send_timeout,
+          :receive_timeout => opts[:receive_timeout] || @receive_timeout,
+        })
+    end
+
+    def start
+      super
+
+      @norikra_started = false
+
+      if @execute_server
+        @norikra_pid = nil
+        @norikra_thread = Thread.new(&method(:server_starter))
+        # @norikra_started will be set in server_starter
+      else
+        @norikra_pid = nil
+        @norikra_thread = nil
+        @norikra_started = true
+      end
+
+      # register worker thread
+      @register_queue = []
+      @register_thread = Thread.new(&method(:register_worker))
+
+      # fetch worker thread
+      @fetch_queue = []
+      @fetch_thread = Thread.new(&method(:fetch_worker))
+
+      # for sweep
+      if @event_method
+        @fetch_queue.push(FetchRequest.new(nil, @event_sweep_interval))
+      end
+    end
+
+    def shutdown
+      @register_thread.kill
+      @fetch_thread.kill
+      Process.kill(:TERM, @norikra_pid) if @execute_server
+
+      @register_thread.join
+      @fetch_thread.join
+      begin
+        counter = 0
+        while !Process.waitpid(@norikra_pid, Process::WNOHANG)
+          sleep 1
+          break if counter > 3
+        end
+      rescue Errno::ECHILD
+        # norikra server process exited.
+      end
+    end
+
+    def server_starter
+      $log.info "starting Norikra server process #{@host}:#{@port}"
+      @norikra_pid = fork do
+        ENV.keys.select{|k| k =~ /^(RUBY|GEM|BUNDLE|RBENV|RVM|rvm)/}.each {|k| ENV.delete(k)}
+        exec [@execute_server_path, 'norikra(fluentd)'], 'start', '-H', @host, '-P', @port.to_s
+      end
+      connecting = true
+      $log.info "trying to confirm norikra server status..."
+      while connecting
+        begin
+          $log.debug "start to connect norikra server #{@host}:#{@port}"
+          client(:connect_timeout => 1, :send_timeout => 1, :receive_timeout => 1).targets
+          # discard result: no exceptions is success
+          connecting = false
+          next
+        rescue HTTPClient::TimeoutError
+          $log.debug "Norikra server test connection timeout. retrying..."
+        rescue Errno::ECONNREFUSED
+          $log.debug "Norikra server test connection refused. retrying..."
+        rescue => e
+          $log.error "unknown error in confirming norikra server, #{e.class}:#{e.message}"
+        end
+        sleep 3
+      end
+      $log.info "confirmed that norikra server #{@host}:#{@port} started."
+      @norikra_started = true
+    end
+
+    def register_worker
+      while sleep(0.25)
+        next unless @norikra_started
+
+        c = client()
+
+        targets = @register_queue.shift(10)
+        targets.each do |t|
+          next if @target_map[t.name]
+
+          $log.debug "Preparing norikra target #{t.name} on #{@host}:#{@port}"
+          if prepare_target(c, t)
+            $log.debug "success to prepare target #{t.name} on #{@host}:#{@port}"
+            # success
+            t.queries.each do |query|
+              @query_map[query.name] = query
+              insert_fetch_queue(FetchRequest.new(query)) unless query.tag.empty? || @event_method
+            end
+            @target_map[t.name] = t
+          else
+            $log.error "Failed to prepare norikra data for target:#{t.name}"
+            @norikra_started.push(t)
+          end
+        end
+      end
+    end
+
+    def fetch_worker
+      while sleep(1)
+        next unless @norikra_started
+        next if @fetch_queue.first.nil? || @fetch_queue.first.time > Time.now
+
+        now = Time.now
+        while @fetch_queue.first.time <= now
+          req = @fetch_queue.shift
+          if req.query.nil?
+            sweep()
+          else
+            fetch(req.query)
+          end
+          insert_fetch_queue(req)
+        end
+      end
+    end
+
+    def format_stream(tag, es)
+      tobe_registered_target_names = []
+
+      out = ''
+
+      es.each do |time,record|
+        target = @target_generator.call(tag, record)
+
+        t = @target_map[target]
+        unless t || tobe_registered_target_names.include?(target)
+          t = Target.new(target, @default_target + @config_targets[target])
+          @register_queue.push(t)
+          tobe_registered_target_names.push(target)
+        end
+
+        event = t.filter(record)
+
+        out << [target,event].to_msgpack
+      end
+
+      out
+    end
+
+    def prepared?(target_names)
+      @norikra_started && target_names.reduce(true){|r,t| r && @target_map[t]}
+    end
+
+    def write(chunk)
+      events_map = {} # target => [event]
+      chunk.msgpack_each do |target, event|
+        events_map[target] ||= []
+        events_map[target].push(event)
+      end
+
+      unless prepared?(events_map.keys)
+        raise RuntimeError, "norikra server is not ready for this targets: #{events_map.keys.join(',')}"
+      end
+
+      c = client()
+
+      events_map.each do |target, events|
+        c.send(target, events)
+      end
+    end
+
+    def prepare_target(client, target)
+      # target open and reserve fields
+      $log.debug "Going to prepare about target"
+      begin
+        unless client.targets.include?(target.name)
+          $log.debug "opening target #{target.name}"
+          client.open(target.name, target.reserve_fields)
+          $log.debug "opening target #{target.name}, done."
+        end
+
+        reserving = target.reserve_fields
+        reserved = []
+        client.fields(target.name).each do |field|
+          if reserving[field['name']]
+            reserved.push(field['name'])
+            if reserving[field['name']] != field['type']
+              $log.warn "field type mismatch, reserving:#{reserving[field['name']]} but reserved:#{field['type']}"
+            end
+          end
+        end
+
+        reserving.each do |fieldname,type|
+          client.reserve(target, fieldname, type) unless reserved.include?(fieldname)
+        end
+      rescue => e
+        $log.error "failed to prepare target:#{target.name}", :norikra => "#{@host}:#{@port}", :error => e.class, :message => e.message
+        return false
+      end
+
+      # query registration
+      begin
+        registered = Hash[client.queries.map{|q| [q['name'], q['expression']]}]
+        target.queries.each do |query|
+          if registered.has_key?(query.name) # query already registered
+            if registered[query.name] != query.expression
+              $log.warn "query name and expression mismatch, check norikra server status. target query name:#{query.name}"
+            end
+            next
+          end
+          client.register(query.name, query.expression)
+        end
+      rescue => e
+        $log.warn "failed to register query", :norikra => "#{@host}:#{@port}", :error => e.class, :message => e.message
+      end
+    end
+
+    class FetchRequest
+      attr_accessor :time, :query
+      def initialize(query, interval=nil)
+        @query = query
+        @interval = interval || query.interval
+        @time = Time.now + @interval
+      end
+      def <=>(other)
+        self.time <=> other.time
+      end
+      def next!
+        @time = Time.now + @interval
+      end
+    end
+
+    def insert_fetch_queue(request)
+      @mutex.synchronize do
+        request.next!
+        # if @fetch_queue.size > 0
+        #   next_pos = @fetch_queue.bsearch{|req| req.time > request.time}
+        #   @fetch_queue.insert(next_pos, request)
+        # else
+        #   @fetch_queue.push(request)
+        # end
+        @fetch_queue.push(request)
+        @fetch_queue.sort!
+      end
+    rescue => e
+      $log.error "unknown log encountered", :error_class => e.class, :message => e.message
+    end
+
+    def sweep
+      begin
+        client().sweep.each do |query_name, event_array|
+          query = @query_map[query_name]
+          event_array.each do |time,event|
+            tag = (query && !query.tag.empty?) ? query.tag : @event_tag_generator.call(query_name, event)
+            Fluent::Engine.emit(tag, time, event)
+          end
+        end
+      rescue => e
+        $log.error "failed to sweep", :norikra => "#{@host}:#{@port}", :error => e.class, :message => e.message
+      end
+    end
+
+    def fetch(query)
+      begin
+        client().event(query.name).each do |time,event| # [[time(int from epoch), event], ...]
+          Fluent::Engine.emit(query.tag, time, event)
+        end
+      rescue => e
+        $log.error "failed to fetch for query:#{query.name}", :norikra => "#{@host}:#{@port}", :error => e.class, :message => e.message
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'fluent/test'
+unless ENV.has_key?('VERBOSE')
+  nulllogger = Object.new
+  nulllogger.instance_eval {|obj|
+    def method_missing(method, *args)
+      # pass
+    end
+  }
+  $log = nulllogger
+end
+
+require 'fluent/plugin/out_norikra'
+
+class Test::Unit::TestCase
+end

data/test/test_config_section.rb

@@ -0,0 +1,179 @@
+require 'helper'
+require 'fluent/plugin/norikra_target'
+
+class ConfigSectionTest < Test::Unit::TestCase
+  def setup
+    @this = Fluent::NorikraOutput::ConfigSection
+  end
+
+  def test_init_default
+    q1 = Fluent::Config::Element.new('query', nil, {
+        'name' => 'q1_${target}',
+        'expression' => 'SELECT * FROM ${target}.win:time_batch(10 min) WHERE q1',
+        'tag' => 'q1.${target}'
+      }, [])
+    q2 = Fluent::Config::Element.new('query', nil, {
+        'name' => 'q2_${target}',
+        'expression' => 'SELECT * FROM ${target}.win:time_batch(50 min) WHERE q2.length() > 0',
+        'tag' => 'q2.${target}'
+      }, [])
+    c1 = Fluent::Config::Element.new('default', nil, {
+        'include' => '*',
+        'exclude' => 'flag',
+        'exclude_regexp' => 'f_.*',
+        'field_string' => 's1,s2,s3',
+        'field_boolean' => 'bool1,bool2',
+        'field_int' => 'i1,i2,i3,i4',
+        'field_long' => 'num1,num2',
+        'field_float' => 'f1,f2',
+        'field_double' => 'd'
+      }, [q1,q2])
+    s1 = @this.new(c1)
+
+    assert_nil s1.target
+    assert_equal({:include => '*', :include_regexp => nil, :exclude => 'flag', :exclude_regexp => 'f_.*'}, s1.filter_params)
+    assert_equal({
+        :string => %w(s1 s2 s3), :boolean => %w(bool1 bool2), :int => %w(i1 i2 i3 i4), :long => %w(num1 num2),
+        :float => %w(f1 f2), :double => %w(d)
+      }, s1.field_definitions)
+    assert_equal 2, s1.query_generators.size
+    assert_equal (10 * 60 / 5), s1.query_generators.map(&:fetch_interval).sort.first
+  end
+
+  def test_init_target
+    q3 = Fluent::Config::Element.new('query', nil, {
+        'name' => 'q3_test2',
+        'expression' => 'SELECT * FROM ${target}.win:time_batch(30 min) WHERE q3="/"',
+        'tag' => 'q3.test2'
+      }, [])
+    c2 = Fluent::Config::Element.new('target', 'test2', {
+        'exclude_regexp' => '(f|g)_.*',
+        'field_double' => 'd1,d2,d3,d4'
+      }, [q3])
+    s2 = @this.new(c2)
+
+    assert_equal 'test2', s2.target
+    assert_equal({:include => nil, :include_regexp => nil, :exclude => nil, :exclude_regexp => '(f|g)_.*'}, s2.filter_params)
+    assert_equal({:string => [], :boolean => [], :int => [], :long => [], :float => [], :double => %w(d1 d2 d3 d4)}, s2.field_definitions)
+    assert_equal 1, s2.query_generators.size
+    assert_equal (30 * 60 / 5), s2.query_generators.map(&:fetch_interval).sort.first
+  end
+
+  def test_init_target_query_only
+    q4 = Fluent::Config::Element.new('query', nil, {
+        'name' => 'q4_test3',
+        'expression' => 'SELECT * FROM ${target}.win:time_batch(30 min) WHERE q4 > 10',
+        'tag' => 'q4.test3',
+        'fetch_interval' => '1s'
+      }, [])
+    c3 = Fluent::Config::Element.new('target', 'test3', {}, [q4])
+    s3 = @this.new(c3)
+
+    assert_equal 'test3', s3.target
+    assert_equal({:include => nil, :include_regexp => nil, :exclude => nil, :exclude_regexp => nil}, s3.filter_params)
+    assert_equal({:string => [], :boolean => [], :int => [], :long => [], :float => [], :double => []}, s3.field_definitions)
+    assert_equal 1, s3.query_generators.size
+  end
+
+  def test_init_target_without_query
+    c4 = Fluent::Config::Element.new('target', 'test4', {
+        'field_int' => 'status'
+      }, [])
+    s4 = @this.new(c4)
+
+    assert_equal 'test4', s4.target
+    assert_equal({:include => nil, :include_regexp => nil, :exclude => nil, :exclude_regexp => nil}, s4.filter_params)
+    assert_equal({:string => [], :boolean => [], :int => ['status'], :long => [], :float => [], :double => []}, s4.field_definitions)
+    assert_equal 0, s4.query_generators.size
+  end
+
+  def test_init_target_blank
+    c5 = Fluent::Config::Element.new('target', 'test5', {}, [])
+    s5 = @this.new(c5)
+
+    assert_equal 'test5', s5.target
+    assert_equal({:include => nil, :include_regexp => nil, :exclude => nil, :exclude_regexp => nil}, s5.filter_params)
+    assert_equal({:string => [], :boolean => [], :int => [], :long => [], :float => [], :double => []}, s5.field_definitions)
+    assert_equal 0, s5.query_generators.size
+  end
+
+  def test_join
+    q1 = Fluent::Config::Element.new('query', nil, {
+        'name' => 'q1_${target}',
+        'expression' => 'SELECT * FROM ${target}.win:time_batch(10 min) WHERE q1',
+        'tag' => 'q1.${target}'
+      }, [])
+    q2 = Fluent::Config::Element.new('query', nil, {
+        'name' => 'q2_${target}',
+        'expression' => 'SELECT * FROM ${target}.win:time_batch(50 min) WHERE q2.length() > 0',
+        'tag' => 'q2.${target}'
+      }, [])
+    c1 = Fluent::Config::Element.new('default', nil, {
+        'include' => '*',
+        'exclude' => 'flag',
+        'exclude_regexp' => 'f_.*',
+        'field_string' => 's1,s2,s3',
+        'field_boolean' => 'bool1,bool2',
+        'field_int' => 'i1,i2,i3,i4',
+        'field_long' => 'num1,num2',
+        'field_float' => 'f1,f2',
+        'field_double' => 'd'
+      }, [q1,q2])
+    s1 = @this.new(c1)
+
+    q3 = Fluent::Config::Element.new('query', nil, {
+        'name' => 'q3_test',
+        'expression' => 'SELECT * FROM ${target}.win:time_batch(30 min) WHERE q3="/"',
+        'tag' => 'q3.test'
+      }, [])
+    c2 = Fluent::Config::Element.new('target', 'test', {
+        'exclude_regexp' => '(f|g)_.*',
+        'field_double' => 'd1,d2,d3,d4'
+      }, [q3])
+    s2 = @this.new(c2)
+
+    s = s1 + s2
+
+    assert_equal 'test', s.target
+    assert_equal({:include => '*', :include_regexp => nil, :exclude => 'flag', :exclude_regexp => '(f|g)_.*'}, s.filter_params)
+    assert_equal({
+        :string => %w(s1 s2 s3), :boolean => %w(bool1 bool2), :int => %w(i1 i2 i3 i4), :long => %w(num1 num2),
+        :float => %w(f1 f2), :double => %w(d d1 d2 d3 d4)
+      }, s.field_definitions)
+    assert_equal 3, s.query_generators.size
+    assert_equal (10 * 60 / 5), s.query_generators.map(&:fetch_interval).sort.first
+  end
+
+  def test_join_with_nil
+    q1 = Fluent::Config::Element.new('query', nil, {
+        'name' => 'q1_${target}',
+        'expression' => 'SELECT * FROM ${target}.win:time_batch(10 min) WHERE q1',
+        'tag' => 'q1.${target}'
+      }, [])
+    q2 = Fluent::Config::Element.new('query', nil, {
+        'name' => 'q2_${target}',
+        'expression' => 'SELECT * FROM ${target}.win:time_batch(50 min) WHERE q2.length() > 0',
+        'tag' => 'q2.${target}'
+      }, [])
+    c1 = Fluent::Config::Element.new('default', nil, {
+        'include' => '*',
+        'exclude' => 'flag',
+        'exclude_regexp' => 'f_.*',
+        'field_string' => 's1,s2,s3',
+        'field_boolean' => 'bool1,bool2',
+        'field_int' => 'i1,i2,i3,i4',
+        'field_long' => 'num1,num2',
+        'field_float' => 'f1,f2',
+        'field_double' => 'd'
+      }, [q1,q2])
+    s1 = @this.new(c1)
+
+    s = s1 + nil
+
+    assert_equal 'dummy', s.target
+    assert_equal s1.filter_params, s.filter_params
+    assert_equal s1.field_definitions, s.field_definitions
+    assert_equal s1.query_generators.size, s.query_generators.size
+    assert_equal s1.query_generators.map(&:fetch_interval).sort.first, s.query_generators.map(&:fetch_interval).sort.first
+  end
+end

data/test/test_query.rb

@@ -0,0 +1,12 @@
+require 'helper'
+require 'fluent/plugin/norikra_target'
+
+class QueryTest < Test::Unit::TestCase
+  def test_init
+    q = Fluent::NorikraOutput::Query.new('name', 'expression', 'tag', 10)
+    assert_equal 'name', q.name
+    assert_equal 'expression', q.expression
+    assert_equal 'tag', q.tag
+    assert_equal 10, q.interval
+  end
+end

data/test/test_query_generator.rb

@@ -0,0 +1,49 @@
+require 'helper'
+require 'fluent/plugin/norikra_target'
+
+class QueryGeneratorTest < Test::Unit::TestCase
+  def setup
+    @this = Fluent::NorikraOutput::QueryGenerator
+  end
+
+  def test_replace_target
+    expected = 'SELECT * FROM replaced.win:time_batch(10 hours) WHERE x=1'
+    assert_equal expected, @this.replace_target('replaced', 'SELECT * FROM ${target}.win:time_batch(10 hours) WHERE x=1')
+  end
+
+  def test_parse_time_period
+    assert_equal [0,0,0,0,0,0,0,0], @this.parse_time_period('')
+
+    assert_equal [10,0,0,0,0,0,0,0], @this.parse_time_period(' 10 year')
+    assert_equal [0,11,0,0,0,0,0,0], @this.parse_time_period('11 month')
+    assert_equal [0,233,0,0,0,0,0,0], @this.parse_time_period('233 months')
+    assert_equal [0,0,10,0,0,0,0,0], @this.parse_time_period('10 weeks')
+    assert_equal [0,0,0,1,0,0,0,0], @this.parse_time_period('1 day')
+    assert_equal [0,0,0,201,0,0,0,0], @this.parse_time_period('201 days')
+    assert_equal [0,0,0,0,1,0,0,0], @this.parse_time_period('1 hour')
+    assert_equal [0,0,0,0,11,0,0,0], @this.parse_time_period('11 hours')
+    assert_equal [0,0,0,0,0,2,0,0], @this.parse_time_period('2 minutes')
+    assert_equal [0,0,0,0,0,1,0,0], @this.parse_time_period('1 min')
+    assert_equal [0,0,0,0,0,133,0,0], @this.parse_time_period('133 minute')
+    assert_equal [0,0,0,0,0,0,12,0], @this.parse_time_period('12 sec')
+    assert_equal [0,0,0,0,0,0,1,0], @this.parse_time_period('1 second')
+    assert_equal [0,0,0,0,0,0,256,0], @this.parse_time_period(' 256 seconds')
+    assert_equal [0,0,0,0,0,0,0,1], @this.parse_time_period('1 msec')
+    assert_equal [0,0,0,0,0,0,0,111], @this.parse_time_period('111 milliseconds')
+
+    assert_equal [1,12,4,365,23,59,60,0], @this.parse_time_period('1 year 12 months 4 weeks 365 days 23 hours 59 min 60 seconds')
+  end
+
+  def test_generate
+    g = @this.new('query_${target}', 'SELECT * FROM ${target}.win:time_batch( 10 min ) WHERE x=1', 'tag.${target}')
+    q = g.generate('test')
+    assert_equal 'query_test', q.name
+    assert_equal 'SELECT * FROM test.win:time_batch( 10 min ) WHERE x=1', q.expression
+    assert_equal 'tag.test', q.tag
+  end
+
+  def test_fetch_interval
+    g = @this.new('query_${target}', 'SELECT * FROM ${target}.win:time_batch( 12 min ) WHERE x=1', 'tag.${target}')
+    assert_equal (12*60/5), g.fetch_interval
+  end
+end