fluentd 1.15.3-x64-mingw-ucrt → 1.16.0-x64-mingw-ucrt

data/lib/fluent/supervisor.rb

@@ -66,9 +66,8 @@ module Fluent
       if config[:disable_shared_socket]
         $log.info "shared socket for multiple workers is disabled"
       else
-        socket_manager_path = ServerEngine::SocketManager::Server.generate_path
-        ServerEngine::SocketManager::Server.open(socket_manager_path)
-        ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
+        server = ServerEngine::SocketManager::Server.open
+        ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = server.path.to_s
       end
     end
 
@@ -91,12 +90,12 @@ module Fluent
       # built-in RPC for signals
       @rpc_server.mount_proc('/api/processes.interruptWorkers') { |req, res|
         $log.debug "fluentd RPC got /api/processes.interruptWorkers request"
-        Process.kill :INT, $$
+        Process.kill :INT, Process.pid
         nil
       }
       @rpc_server.mount_proc('/api/processes.killWorkers') { |req, res|
         $log.debug "fluentd RPC got /api/processes.killWorkers request"
-        Process.kill :TERM, $$
+        Process.kill :TERM, Process.pid
         nil
       }
       @rpc_server.mount_proc('/api/processes.flushBuffersAndKillWorkers') { |req, res|
@@ -105,8 +104,8 @@ module Fluent
           supervisor_sigusr1_handler
           stop(true)
         else
-          Process.kill :USR1, $$
-          Process.kill :TERM, $$
+          Process.kill :USR1, Process.pid
+          Process.kill :TERM, Process.pid
         end
         nil
       }
@@ -115,7 +114,7 @@ module Fluent
         if Fluent.windows?
           supervisor_sigusr1_handler
         else
-          Process.kill :USR1, $$
+          Process.kill :USR1, Process.pid
         end
         nil
       }
@@ -125,7 +124,7 @@ module Fluent
           # restart worker with auto restarting by killing
           kill_worker
         else
-          Process.kill :HUP, $$
+          Process.kill :HUP, Process.pid
         end
         nil
       }
@@ -141,7 +140,7 @@ module Fluent
         if Fluent.windows?
           supervisor_sigusr2_handler
         else
-          Process.kill :USR2, $$
+          Process.kill :USR2, Process.pid
         end
 
         nil
@@ -213,7 +212,7 @@ module Fluent
     def install_windows_event_handler
       return unless Fluent.windows?
 
-      @pid_signame = "fluentd_#{$$}"
+      @pid_signame = "fluentd_#{Process.pid}"
       @signame = config[:signame]
 
       Thread.new do
@@ -355,14 +354,18 @@ module Fluent
       { conf: @fluentd_conf }
     end
 
+    def dump
+      super unless @stop
+    end
+
     private
 
     def reopen_log
-      if (log = config[:logger_initializer])
+      if $log
         # Creating new thread due to mutex can't lock
         # in main thread during trap context
         Thread.new do
-          log.reopen!
+          $log.reopen!
         end
       end
     end
@@ -413,47 +416,14 @@ module Fluent
     def after_start
       (config[:worker_pid] ||= {})[@worker_id] = @pm.pid
     end
+
+    def dump
+      super unless @stop
+    end
   end
 
   class Supervisor
-    def self.load_config(path, params = {})
-      pre_loadtime = 0
-      pre_loadtime = params['pre_loadtime'].to_i if params['pre_loadtime']
-      pre_config_mtime = nil
-      pre_config_mtime = params['pre_config_mtime'] if params['pre_config_mtime']
-      config_mtime = File.mtime(path)
-
-      # reuse previous config if last load time is within 5 seconds and mtime of the config file is not changed
-      if (Time.now - Time.at(pre_loadtime) < 5) && (config_mtime == pre_config_mtime)
-        return params['pre_conf']
-      end
-
-      log_level = params['log_level']
-      suppress_repeated_stacktrace = params['suppress_repeated_stacktrace']
-      ignore_repeated_log_interval = params['ignore_repeated_log_interval']
-      ignore_same_log_interval = params['ignore_same_log_interval']
-
-      log_path = params['log_path']
-      chuser = params['chuser']
-      chgroup = params['chgroup']
-      chumask = params['chumask']
-      log_rotate_age = params['log_rotate_age']
-      log_rotate_size = params['log_rotate_size']
-
-      log_opts = {suppress_repeated_stacktrace: suppress_repeated_stacktrace, ignore_repeated_log_interval: ignore_repeated_log_interval,
-                  ignore_same_log_interval: ignore_same_log_interval}
-      logger_initializer = Supervisor::LoggerInitializer.new(
-        log_path, log_level, chuser, chgroup, log_opts,
-        log_rotate_age: log_rotate_age,
-        log_rotate_size: log_rotate_size
-      )
-      # this #init sets initialized logger to $log
-      logger_initializer.init(:supervisor, 0)
-      logger_initializer.apply_options(format: params['log_format'], time_format: params['log_time_format'])
-      logger = $log
-
-      command_sender = Fluent.windows? ? "pipe" : "signal"
-
+    def self.serverengine_config(params = {})
       # ServerEngine's "daemonize" option is boolean, and path of pid file is brought by "pid_path"
       pid_path = params['daemonize']
       daemonize = !!params['daemonize']
@@ -469,17 +439,12 @@ module Fluent
         unrecoverable_exit_codes: [2],
         stop_immediately_at_unrecoverable_exit: true,
         root_dir: params['root_dir'],
-        logger: logger,
-        log: logger.out,
-        log_path: log_path,
-        log_level: log_level,
-        logger_initializer: logger_initializer,
-        chuser: chuser,
-        chgroup: chgroup,
-        chumask: chumask,
-        suppress_repeated_stacktrace: suppress_repeated_stacktrace,
-        ignore_repeated_log_interval: ignore_repeated_log_interval,
-        ignore_same_log_interval: ignore_same_log_interval,
+        logger: $log,
+        log: $log.out,
+        log_level: params['log_level'],
+        chuser: params['chuser'],
+        chgroup: params['chgroup'],
+        chumask: params['chumask'],
         daemonize: daemonize,
         rpc_endpoint: params['rpc_endpoint'],
         counter_server: params['counter_server'],
@@ -488,132 +453,22 @@ module Fluent
                                  File.join(File.dirname(__FILE__), 'daemon.rb'),
                                  ServerModule.name,
                                  WorkerModule.name,
-                                 path,
                                  JSON.dump(params)],
-        command_sender: command_sender,
+        command_sender: Fluent.windows? ? "pipe" : "signal",
+        config_path: params['fluentd_conf_path'],
         fluentd_conf: params['fluentd_conf'],
         conf_encoding: params['conf_encoding'],
         inline_config: params['inline_config'],
-        config_path: path,
         main_cmd: params['main_cmd'],
         signame: params['signame'],
         disable_shared_socket: params['disable_shared_socket'],
         restart_worker_interval: params['restart_worker_interval'],
       }
-      if daemonize
-        se_config[:pid_path] = pid_path
-      end
-      pre_params = params.dup
-      params['pre_loadtime'] = Time.now.to_i
-      params['pre_config_mtime'] = config_mtime
-      params['pre_conf'] = se_config
-      # prevent pre_conf from being too big by reloading many times.
-      pre_params['pre_conf'] = nil
-      params['pre_conf'][:windows_daemon_cmdline][5] = JSON.dump(pre_params)
+      se_config[:pid_path] = pid_path if daemonize
 
       se_config
     end
 
-    class LoggerInitializer
-      def initialize(path, level, chuser, chgroup, opts, log_rotate_age: nil, log_rotate_size: nil)
-        @path = path
-        @level = level
-        @chuser = chuser
-        @chgroup = chgroup
-        @opts = opts
-        @log_rotate_age = log_rotate_age
-        @log_rotate_size = log_rotate_size
-      end
-
-      # Create a unique path for each process.
-      #
-      # >>> per_process_path(:worker, 1, "C:/tmp/test.log")
-      # C:/tmp/test-1.log
-      # >>> per_process_path(:supervisor, 0, "C:/tmp/test.log")
-      # C:/tmp/test-supervisor-0.log
-      def self.per_process_path(path, process_type, worker_id)
-        path = Pathname(path)
-        ext = path.extname
-
-        if process_type == :supervisor
-          suffix = "-#{process_type}-0#{ext}"  # "-0" for backword compatibility.
-        else
-          suffix = "-#{worker_id}#{ext}"
-        end
-        return path.sub_ext(suffix).to_s
-      end
-
-      def init(process_type, worker_id)
-        @opts[:process_type] = process_type
-        @opts[:worker_id] = worker_id
-
-        if @path && @path != "-"
-          unless File.exist?(@path)
-            FileUtils.mkdir_p(File.dirname(@path))
-          end
-
-          if @log_rotate_age || @log_rotate_size
-            # We need to prepare a unique path for each worker since
-            # Windows locks files.
-            if Fluent.windows?
-                path = LoggerInitializer.per_process_path(@path, process_type, worker_id)
-            else
-                path = @path
-            end
-            @logdev = Fluent::LogDeviceIO.new(path, shift_age: @log_rotate_age, shift_size: @log_rotate_size)
-          else
-            @logdev = File.open(@path, "a")
-          end
-
-          if @chuser || @chgroup
-            chuid = @chuser ? ServerEngine::Privilege.get_etc_passwd(@chuser).uid : nil
-            chgid = @chgroup ? ServerEngine::Privilege.get_etc_group(@chgroup).gid : nil
-            File.chown(chuid, chgid, @path)
-          end
-        else
-          @logdev = STDOUT
-        end
-
-        dl_opts = {}
-        # subtract 1 to match serverengine daemon logger side logging severity.
-        dl_opts[:log_level] = @level - 1
-        dl_opts[:log_rotate_age] = @log_rotate_age if @log_rotate_age
-        dl_opts[:log_rotate_size] = @log_rotate_size if @log_rotate_size
-        logger = ServerEngine::DaemonLogger.new(@logdev, dl_opts)
-        $log = Fluent::Log.new(logger, @opts)
-        $log.enable_color(false) if @path
-        $log.enable_debug if @level <= Fluent::Log::LEVEL_DEBUG
-        $log.info "init #{process_type} logger", path: path, rotate_age: @log_rotate_age, rotate_size: @log_rotate_size
-      end
-
-      def stdout?
-        @logdev == STDOUT
-      end
-
-      def reopen!
-        if @path && @path != "-"
-          @logdev.reopen(@path, "a")
-        end
-        self
-      end
-
-      def apply_options(format: nil, time_format: nil, log_dir_perm: nil, ignore_repeated_log_interval: nil, ignore_same_log_interval: nil)
-        $log.format = format if format
-        $log.time_format = time_format if time_format
-        $log.ignore_repeated_log_interval = ignore_repeated_log_interval if ignore_repeated_log_interval
-        $log.ignore_same_log_interval = ignore_same_log_interval if ignore_same_log_interval
-
-        if @path && log_dir_perm
-          File.chmod(log_dir_perm || Fluent::DEFAULT_DIR_PERMISSION, File.dirname(@path))
-        end
-      end
-
-      def level=(level)
-        @level = level
-        $log.level = level
-      end
-    end
-
     def self.default_options
       {
         config_path: Fluent::DEFAULT_CONFIG_PATH,
@@ -652,7 +507,10 @@ module Fluent
       end
     end
 
-    def initialize(opt)
+    def initialize(cl_opt)
+      @cl_opt = cl_opt
+      opt = self.class.default_options.merge(cl_opt)
+
       @config_file_type = opt[:config_file_type]
       @daemonize = opt[:daemonize]
       @standalone_worker= opt[:standalone_worker]
@@ -667,36 +525,18 @@ module Fluent
       @chgroup = opt[:chgroup]
       @chuser = opt[:chuser]
       @chumask = opt[:chumask]
+      @signame = opt[:signame]
 
+      # TODO: `@log_rotate_age` and `@log_rotate_size` should be removed
+      # since it should be merged with SystemConfig in `build_system_config()`.
+      # We should always use `system_config.log.rotate_age` and `system_config.log.rotate_size`.
+      # However, currently, there is a bug that `system_config.log` parameters
+      # are not in `Fluent::SystemConfig::SYSTEM_CONFIG_PARAMETERS`, and these
+      # parameters are not merged in `build_system_config()`.
+      # Until we fix the bug of `Fluent::SystemConfig`, we need to use these instance variables.
       @log_rotate_age = opt[:log_rotate_age]
       @log_rotate_size = opt[:log_rotate_size]
-      @signame = opt[:signame]
-
-      @cl_opt = opt
-      @conf = nil
-      # parse configuration immediately to initialize logger in early stage
-      if @config_path and File.exist?(@config_path)
-        @conf = Fluent::Config.build(config_path: @config_path,
-                                     encoding: @conf_encoding ? @conf_encoding : 'utf-8',
-                                     additional_config: @inline_config ? @inline_config : nil,
-                                     use_v1_config: !!@use_v1_config,
-                                     type: @config_file_type,
-                                    )
-        @system_config = build_system_config(@conf)
-        if @system_config.log
-          @log_rotate_age ||= @system_config.log.rotate_age
-          @log_rotate_size ||= @system_config.log.rotate_size
-        end
-        @conf = nil
-      end
 
-      log_opts = {suppress_repeated_stacktrace: opt[:suppress_repeated_stacktrace], ignore_repeated_log_interval: opt[:ignore_repeated_log_interval],
-                  ignore_same_log_interval: opt[:ignore_same_log_interval]}
-      @log = LoggerInitializer.new(
-        @log_path, opt[:log_level], @chuser, @chgroup, log_opts,
-        log_rotate_age: @log_rotate_age,
-        log_rotate_size: @log_rotate_size
-      )
       @finished = false
     end
 
@@ -754,12 +594,6 @@ module Fluent
     end
 
     def run_worker
-      begin
-        require 'sigdump/setup'
-      rescue Exception
-        # ignore LoadError and others (related with signals): it may raise these errors in Windows
-      end
-
       Process.setproctitle("worker:#{@system_config.process_name}") if @process_name
 
       if @standalone_worker && @system_config.workers != 1
@@ -787,17 +621,7 @@ module Fluent
     end
 
     def configure(supervisor: false)
-      if supervisor
-        @log.init(:supervisor, 0)
-      else
-        worker_id = ENV['SERVERENGINE_WORKER_ID'].to_i
-        process_type = case
-                       when @standalone_worker then :standalone
-                       when worker_id == 0 then :worker0
-                       else :workers
-                       end
-        @log.init(process_type, worker_id)
-      end
+      setup_global_logger(supervisor: supervisor)
 
       if @show_plugin_config
         show_plugin_config
@@ -816,15 +640,6 @@ module Fluent
       )
       @system_config = build_system_config(@conf)
 
-      @log.level = @system_config.log_level
-      @log.apply_options(
-        format: @system_config.log.format,
-        time_format: @system_config.log.time_format,
-        log_dir_perm: @system_config.dir_permission,
-        ignore_repeated_log_interval: @system_config.ignore_repeated_log_interval,
-        ignore_same_log_interval: @system_config.ignore_same_log_interval
-      )
-
       $log.info :supervisor, 'parsing config file is succeeded', path: @config_path
 
       @libs.each do |lib|
@@ -848,10 +663,93 @@ module Fluent
 
     private
 
+    def setup_global_logger(supervisor: false)
+      if supervisor
+        worker_id = 0
+        process_type = :supervisor
+      else
+        worker_id = ENV['SERVERENGINE_WORKER_ID'].to_i
+        process_type = case
+                       when @standalone_worker then :standalone
+                       when worker_id == 0 then :worker0
+                       else :workers
+                       end
+      end
+
+      # Parse configuration immediately to initialize logger in early stage.
+      # Since we can't confirm the log messages in this parsing process,
+      # we must parse the config again after initializing logger.
+      conf = Fluent::Config.build(
+        config_path: @config_path,
+        encoding: @conf_encoding,
+        additional_config: @inline_config,
+        use_v1_config: @use_v1_config,
+        type: @config_file_type,
+      )
+      system_config = build_system_config(conf)
+
+      # TODO: we should remove this logic. This merging process should be done
+      # in `build_system_config()`.
+      @log_rotate_age ||= system_config.log.rotate_age
+      @log_rotate_size ||= system_config.log.rotate_size
+
+      rotate = @log_rotate_age || @log_rotate_size
+      actual_log_path = @log_path
+
+      # We need to prepare a unique path for each worker since Windows locks files.
+      if Fluent.windows? && rotate
+        actual_log_path = Fluent::Log.per_process_path(@log_path, process_type, worker_id)
+      end
+
+      if actual_log_path && actual_log_path != "-"
+        FileUtils.mkdir_p(File.dirname(actual_log_path)) unless File.exist?(actual_log_path)
+        if rotate
+          logdev = Fluent::LogDeviceIO.new(
+            actual_log_path,
+            shift_age: @log_rotate_age,
+            shift_size: @log_rotate_size,
+          )
+        else
+          logdev = File.open(actual_log_path, "a")
+        end
+
+        if @chuser || @chgroup
+          chuid = @chuser ? ServerEngine::Privilege.get_etc_passwd(@chuser).uid : nil
+          chgid = @chgroup ? ServerEngine::Privilege.get_etc_group(@chgroup).gid : nil
+          File.chown(chuid, chgid, actual_log_path)
+        end
+
+        if system_config.dir_permission
+          File.chmod(system_config.dir_permission || Fluent::DEFAULT_DIR_PERMISSION, File.dirname(actual_log_path))
+        end
+      else
+        logdev = STDOUT
+      end
+
+      $log = Fluent::Log.new(
+        # log_level: subtract 1 to match serverengine daemon logger side logging severity.
+        ServerEngine::DaemonLogger.new(logdev, log_level: system_config.log_level - 1),
+        path: actual_log_path,
+        process_type: process_type,
+        worker_id: worker_id,
+        format: system_config.log.format,
+        time_format: system_config.log.time_format,
+        suppress_repeated_stacktrace: system_config.suppress_repeated_stacktrace,
+        ignore_repeated_log_interval: system_config.ignore_repeated_log_interval,
+        ignore_same_log_interval: system_config.ignore_same_log_interval,
+      )
+      $log.enable_color(false) if actual_log_path
+      $log.enable_debug if system_config.log_level <= Fluent::Log::LEVEL_DEBUG
+
+      $log.info "init #{process_type} logger",
+                path: actual_log_path, 
+                rotate_age: @log_rotate_age,
+                rotate_size: @log_rotate_size
+    end
+
     def create_socket_manager
-      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
-      ServerEngine::SocketManager::Server.open(socket_manager_path)
-      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
+      server = ServerEngine::SocketManager::Server.open
+      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = server.path.to_s
     end
 
     def show_plugin_config
@@ -871,32 +769,28 @@ module Fluent
         'main_cmd' => fluentd_spawn_cmd,
         'daemonize' => @daemonize,
         'inline_config' => @inline_config,
-        'log_path' => @log_path,
-        'log_rotate_age' => @log_rotate_age,
-        'log_rotate_size' => @log_rotate_size,
         'chuser' => @chuser,
         'chgroup' => @chgroup,
+        'fluentd_conf_path' => @config_path,
+        'fluentd_conf' => @conf.to_s,
         'use_v1_config' => @use_v1_config,
         'conf_encoding' => @conf_encoding,
         'signame' => @signame,
-        'fluentd_conf' => @conf.to_s,
 
         'workers' => @system_config.workers,
         'root_dir' => @system_config.root_dir,
         'log_level' => @system_config.log_level,
-        'suppress_repeated_stacktrace' => @system_config.suppress_repeated_stacktrace,
-        'ignore_repeated_log_interval' => @system_config.ignore_repeated_log_interval,
         'rpc_endpoint' => @system_config.rpc_endpoint,
         'enable_get_dump' => @system_config.enable_get_dump,
         'counter_server' => @system_config.counter_server,
-        'log_format' => @system_config.log.format,
-        'log_time_format' => @system_config.log.time_format,
         'disable_shared_socket' => @system_config.disable_shared_socket,
         'restart_worker_interval' => @system_config.restart_worker_interval,
       }
 
-      se = ServerEngine.create(ServerModule, WorkerModule){
-        Fluent::Supervisor.load_config(@config_path, params)
+      se = ServerEngine.create(ServerModule, WorkerModule) {
+        # Note: This is called only at the initialization of ServerEngine, since
+        # Fluentd overwrites all related SIGNAL(HUP,USR1,USR2) and have own reloading feature.
+        Fluent::Supervisor.serverengine_config(params)
       }
 
       se.run
@@ -940,6 +834,10 @@ module Fluent
         trap :USR2 do
           reload_config
         end
+
+        trap :CONT do
+          dump_non_windows
+        end
       end
     end
 
@@ -969,7 +867,7 @@ module Fluent
             reload_config
           when "DUMP"
             $log.debug "fluentd main process get #{cmd} command"
-            dump
+            dump_windows
           else
             $log.warn "fluentd main process get unknown command [#{cmd}]"
           end
@@ -984,7 +882,7 @@ module Fluent
         begin
           $log.debug "fluentd main process get SIGUSR1"
           $log.info "force flushing buffered events"
-          @log.reopen!
+          $log.reopen!
           Fluent::Engine.flush!
           $log.debug "flushing thread: flushed"
         rescue Exception => e
@@ -1020,7 +918,15 @@ module Fluent
       end
     end
 
-    def dump
+    def dump_non_windows
+      begin
+        Sigdump.dump unless @finished
+      rescue => e
+        $log.error("failed to dump: #{e}")
+      end
+    end
+
+    def dump_windows
       Thread.new do
         begin
           FluentSigdump.dump_windows
@@ -1032,7 +938,7 @@ module Fluent
 
     def logging_with_console_output
       yield $log
-      unless @log.stdout?
+      unless $log.stdout?
         logger = ServerEngine::DaemonLogger.new(STDOUT)
         log = Fluent::Log.new(logger)
         log.level = @system_config.log_level
@@ -1088,15 +994,15 @@ module Fluent
 
     def build_system_config(conf)
       system_config = SystemConfig.create(conf, @cl_opt[:strict_config_value])
+      # Prefer the options explicitly specified in the command line
+      # 
+      # TODO: There is a bug that `system_config.log.rotate_age/rotate_size` are
+      # not merged with the command line options since they are not in
+      # `SYSTEM_CONFIG_PARAMETERS`.
+      # We have to fix this bug.
       opt = {}
       Fluent::SystemConfig::SYSTEM_CONFIG_PARAMETERS.each do |param|
         if @cl_opt.key?(param) && !@cl_opt[param].nil?
-          if param == :log_level && @cl_opt[:log_level] == Fluent::Log::LEVEL_INFO
-            # info level can't be specified via command line option.
-            # log_level is info here, it is default value and <system>'s log_level should be applied if exists.
-            next
-          end
-
           opt[param] = @cl_opt[param]
         end
       end

data/lib/fluent/test/driver/base.rb

@@ -16,6 +16,7 @@
 
 require 'fluent/config'
 require 'fluent/config/element'
+require 'fluent/env'
 require 'fluent/log'
 require 'fluent/clock'
 
@@ -102,11 +103,16 @@ module Fluent
 
         def instance_start
           if @instance.respond_to?(:server_wait_until_start)
-            @socket_manager_path = ServerEngine::SocketManager::Server.generate_path
-            if @socket_manager_path.is_a?(String) && File.exist?(@socket_manager_path)
-              FileUtils.rm_f @socket_manager_path
+            if Fluent.windows?
+              @socket_manager_server = ServerEngine::SocketManager::Server.open
+              @socket_manager_path = @socket_manager_server.path
+            else
+              @socket_manager_path = ServerEngine::SocketManager::Server.generate_path
+              if @socket_manager_path.is_a?(String) && File.exist?(@socket_manager_path)
+                FileUtils.rm_f @socket_manager_path
+              end
+              @socket_manager_server = ServerEngine::SocketManager::Server.open(@socket_manager_path)
             end
-            @socket_manager_server = ServerEngine::SocketManager::Server.open(@socket_manager_path)
             ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = @socket_manager_path.to_s
           end
 
@@ -173,7 +179,7 @@ module Fluent
 
           if @socket_manager_server
             @socket_manager_server.close
-            if @socket_manager_server.is_a?(String) && File.exist?(@socket_manager_path)
+            if @socket_manager_path.is_a?(String) && File.exist?(@socket_manager_path)
               FileUtils.rm_f @socket_manager_path
             end
           end

data/lib/fluent/test/driver/filter.rb

@@ -37,6 +37,10 @@ module Fluent
           @filtered.map {|_time, record| record }
         end
 
+        def filtered_time
+          @filtered.map {|time, _record| time }
+        end
+
         def instance_hook_after_started
           super
           filter_hook = ->(time, record) { @filtered << [time, record] }