droonga-engine 1.0.9 → 1.1.0

data/lib/droonga/plugins/system/statistics.rb

@@ -0,0 +1,71 @@
+# Copyright (C) 2015 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "droonga/plugin"
+require "droonga/database_scanner"
+
+module Droonga
+  module Plugins
+    module System
+      class StatisticsObjectCountHandler < Droonga::Handler
+        include DatabaseScanner
+
+        def handle(message)
+          counts(message.request["output"])
+        end
+
+        def counts(output)
+          counts = {}
+          if output and output.is_a?(Array)
+            if output.include?("tables")
+              counts["tables"] = n_tables
+            end
+            if output.include?("columns")
+              counts["columns"] = n_columns
+            end
+            if output.include?("records")
+              counts["records"] = n_records
+            end
+            if output.include?("total")
+              counts["total"] = total_n_objects
+            end
+          end
+          counts
+        end
+      end
+
+      define_single_step do |step|
+        step.name = "system.statistics.object.count"
+        step.handler = StatisticsObjectCountHandler
+        step.collector = Collectors::RecursiveSum
+      end
+
+      class StatisticsObjectCountPerVolumeHandler < StatisticsObjectCountHandler
+        def handle(message)
+          {
+            label => counts(message.request["output"]),
+          }
+        end
+      end
+
+      define_single_step do |step|
+        step.name = "system.statistics.object.count.per-volume"
+        step.use_all_replicas = true
+        step.handler = StatisticsObjectCountPerVolumeHandler
+        step.collector = Collectors::Sum
+      end
+    end
+  end
+end

data/lib/droonga/plugins/system/status.rb

@@ -0,0 +1,53 @@
+# Copyright (C) 2013-2015 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "droonga/plugin"
+
+module Droonga
+  module Plugins
+    module System
+      class StatusHandler < Droonga::Handler
+        action.synchronous = true
+
+        def handle(message)
+          {
+            "nodes"    => cluster.engine_nodes_status,
+            "reporter" => reporter,
+          }
+        end
+
+        private
+        def cluster
+          @messenger.cluster
+        end
+
+        def reporter
+          "#{engine_state.internal_name} @ #{engine_state.name}"
+        end
+
+        def engine_state
+          @messenger.engine_state
+        end
+      end
+
+      define_single_step do |step|
+        step.name = "system.status"
+        step.single_operation = true
+        step.handler = StatusHandler
+        step.collector = Collectors::Or
+      end
+    end
+  end
+end

data/lib/droonga/process_control_protocol.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014 Droonga Project
+# Copyright (C) 2014-2015 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -18,6 +18,8 @@ module Droonga
     module Messages
       STOP_GRACEFUL    = "stop-graceful\n"
       STOP_IMMEDIATELY = "stop-immediately\n"
+      REFRESH_SELF_REFERENCE = "refresh-self-reference\n"
+      REFRESH_NODE_REFERENCE = "refresh-node-reference\n"
 
       READY  = "ready\n"
       FINISH = "finish\n"

data/lib/droonga/process_supervisor.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014 Droonga Project
+# Copyright (C) 2014-2015 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -15,52 +15,72 @@
 
 require "coolio"
 
+require "droonga/loggable"
+require "droonga/deferrable"
 require "droonga/process_control_protocol"
 require "droonga/line_buffer"
 
 module Droonga
   class ProcessSupervisor
+    include Loggable
+    include Deferrable
     include ProcessControlProtocol
 
+    attr_writer :on_finish
+
     def initialize(loop, input, output)
       @loop = loop
       @input = create_input(input)
       @output = create_output(output)
-      @on_ready = nil
-      @on_finish = nil
     end
 
     def start
       @loop.attach(@input)
+      logger.trace("start: input watcher attached",
+                   :watcher => @input)
       @loop.attach(@output)
+      logger.trace("start: output watcher attached",
+                   :watcher => @output)
     end
 
     def stop
       @input.close
+      logger.trace("stop: input watcher detached",
+                   :watcher => @input)
       @output.close
+      logger.trace("stop: output watcher detached",
+                   :watcher => @output)
     end
 
     def stop_gracefully
+      logger.trace("stop_gracefully: start")
       @output.write(Messages::STOP_GRACEFUL)
+      logger.trace("stop_gracefully: done")
     end
 
     def stop_immediately
+      logger.trace("stop_immediately: start")
       @output.write(Messages::STOP_IMMEDIATELY)
+      logger.trace("stop_immediately: done")
     end
 
-    def on_ready=(callback)
-      @on_ready = callback
+    def refresh_self_reference
+      logger.trace("refresh_self_reference: start")
+      @output.write(Messages::REFRESH_SELF_REFERENCE)
+      logger.trace("refresh_self_reference: done")
     end
 
-    def on_finish=(callback)
-      @on_finish = callback
+    def refresh_node_reference
+      logger.trace("refresh_node_reference: start")
+      @output.write(Messages::REFRESH_NODE_REFERENCE)
+      logger.trace("refresh_node_reference: done")
     end
 
     private
     def create_input(raw_input)
       input = Coolio::IO.new(raw_input)
       line_buffer = LineBuffer.new
-      on_read = lambda do |data|
+      input.on_read do |data|
         line_buffer.feed(data) do |line|
           case line
           when Messages::READY
@@ -70,9 +90,6 @@ module Droonga
           end
         end
       end
-      input.on_read do |data|
-        on_read.call(data)
-      end
       input
     end
 
@@ -80,12 +97,12 @@ module Droonga
       Coolio::IO.new(raw_output)
     end
 
-    def on_ready
-      @on_ready.call if @on_ready
-    end
-
     def on_finish
       @on_finish.call if @on_finish
     end
+
+    def log_tag
+      "process_supervisor"
+    end
   end
 end

data/lib/droonga/reducer.rb

@@ -58,6 +58,10 @@ module Droonga
         reduced_value = sum(left_value, right_value)
         reduced_value = self.class.apply_range(reduced_value,
                                                "limit" => @deal["limit"])
+      when "recursive-sum"
+        reduced_value = recursive_sum(left_value, right_value)
+        reduced_value = self.class.apply_range(reduced_value,
+                                               "limit" => @deal["limit"])
       when "average"
         reduced_value = (left_value.to_f + right_value.to_f) / 2
       when "sort"
@@ -83,6 +87,22 @@ module Droonga
       end
     end
 
+    def recursive_sum(x, y)
+      return x || y if x.nil? or y.nil?
+
+      if x.is_a?(Hash) and y.is_a?(Hash)
+        if numeric_hash?(x) and numeric_hash?(y)
+          sum_numeric_hashes(x, y)
+        else
+          x.merge(y)
+        end
+      elsif numeric_array?(x) and numeric_array?(y)
+        sum_numeric_array(x, y)
+      else
+        x + y
+      end
+    end
+
     def merge(x, y, options={})
       operators = options[:operators] = normalize_operators(options[:operators])
 
@@ -165,5 +185,54 @@ module Droonga
         end
       end
     end
+
+    def numeric_array?(array)
+      return false unless array.is_a?(Array)
+      array.all? do |value|
+        case value
+        when Numeric
+          true
+        when Hash
+          numeric_hash?(value)
+        when Array
+          numeric_array?(value)
+        else
+          false
+        end
+      end
+    end
+
+    def numeric_hash?(hash)
+      return false unless hash.is_a?(Hash)
+      numeric_array?(hash.values)
+    end
+
+    def sum_numeric_values(x, y)
+      if x.nil? or y.nil?
+        x || y
+      elsif numeric_array?(x) and numeric_array?(y)
+        sum_numeric_arrays(x, y)
+      elsif numeric_hash?(x) and numeric_hash?(y)
+        sum_numeric_hashes(x, y)
+      else
+        x + y
+      end
+    end
+
+    def sum_numeric_arrays(x, y)
+      sum = []
+      [x.size, y.size].max.times do |index|
+        sum << sum_numeric_values(x[index], y[index])
+      end
+      sum
+    end
+
+    def sum_numeric_hashes(x, y)
+      sum = {}
+      (x.keys + y.keys).uniq.each do |key|
+        sum[key] = sum_numeric_values(x[key], y[key])
+      end
+      sum
+    end
   end
 end

data/lib/droonga/safe_file_writer.rb

@@ -24,7 +24,7 @@ module Droonga
         # Don't output the file directly to prevent loading of incomplete file!
         path = Pathname(path).expand_path
         FileUtils.mkdir_p(path.dirname.to_s)
-        Tempfile.open(path.basename.to_s, path.dirname.to_s, "w") do |output|
+        Tempfile.open(path.basename.to_s, path.dirname.to_s) do |output|
           if block_given?
             yield(output, output.path)
           else

data/lib/droonga/serf.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014 Droonga Project
+# Copyright (C) 2014-2015 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -13,161 +13,256 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-require "English"
-
 require "json"
-require "coolio"
-require "open3"
 
 require "droonga/path"
 require "droonga/loggable"
-require "droonga/catalog_loader"
-require "droonga/node_status"
-require "droonga/serf_downloader"
+require "droonga/catalog/loader"
+require "droonga/node_name"
+require "droonga/node_role"
+require "droonga/serf/tag"
+require "droonga/serf/downloader"
+require "droonga/serf/agent"
+require "droonga/serf/command"
 require "droonga/line_buffer"
+require "droonga/safe_file_writer"
+require "droonga/service_installation"
 
 module Droonga
   class Serf
-    ROLE = {
-      :default => {
-        :port => 7946,
-      },
-      :source => {
-        :port => 7947,
-      },
-      :destination => {
-        :port => 7948,
-      },
-    }
-
-    class << self
-      def path
-        Droonga::Path.base + "serf"
-      end
-    end
-
     include Loggable
 
-    def initialize(loop, name)
-      # TODO: Don't allow nil for loop. It reduces nil checks and
-      # simplifies source code.
-      @loop = loop
-      @name = name
-      @agent = nil
+    def initialize(name, options={})
+      @serf_command = nil
+      @name = NodeName.parse(name)
+      @verbose = options[:verbose] || false
+      @service_installation = ServiceInstallation.new
+      @tags_cache = {}
     end
 
-    def start
-      logger.trace("start: start")
+    def run_agent(loop)
+      logger.trace("run_agent: start")
       ensure_serf
-      ENV["SERF"] = @serf
-      ENV["SERF_RPC_ADDRESS"] = rpc_address
       retry_joins = []
       detect_other_hosts.each do |other_host|
         retry_joins.push("-retry-join", other_host)
       end
-      @agent = run("agent",
-                   "-node", @name,
-                   "-bind", "#{extract_host(@name)}:#{port}",
-                   "-event-handler", "droonga-engine-serf-event-handler",
-                   "-log-level", log_level,
-                   "-tag", "role=engine",
-                   "-tag", "cluster_id=#{cluster_id}",
-                   *retry_joins)
-      logger.trace("start: done")
+      tags_file = Path.serf_tags_file
+      FileUtils.mkdir_p(tags_file.dirname)
+      agent = Agent.new(loop, @serf_command,
+                        @name.host, agent_port, rpc_port,
+                        "-node", @name.to_s,
+                        "-event-handler", "droonga-engine-serf-event-handler",
+                        "-tags-file", tags_file.to_s,
+                        *retry_joins)
+      agent.start
+      logger.trace("run_agent: done")
+      agent
     end
 
-    def running?
-      @agent and @agent.running?
+    def initialize_tags
+      set_tag(Tag.node_type, "engine")
+      set_tag(Tag.node_role, role)
+      set_tag(Tag.cluster_id, cluster_id)
     end
 
-    def stop
-      logger.trace("stop: start")
-      run("leave").stop
-      @agent.stop
-      @agent = nil
-      logger.trace("stop: done")
-    end
-
-    def restart
-      logger.trace("restart: start")
-      stop
-      start
-      logger.trace("restart: done")
+    def leave
+      run_command("leave")
     end
 
     def join(*hosts)
-      ensure_serf
       nodes = hosts.collect do |host|
-        "#{host}:#{port}"
+        "#{host}:#{agent_port}"
       end
-      run_once("join", *nodes)
+      run_command("join", *nodes)
     end
 
     def send_query(query, payload)
-      ensure_serf
       options = ["-format", "json"] + additional_options_from_payload(payload)
       options += [query, JSON.generate(payload)]
-      result = run_once("query", *options)
-      result[:result] = JSON.parse(result[:result])
-      if payload["node"]
-        responses = result[:result]["Responses"]
-        response = responses[payload["node"]]
+      raw_serf_response = run_command("query", *options)
+      serf_response = JSON.parse(raw_serf_response)
+
+      node = payload["node"]
+      if node
+        responses = serf_response["Responses"]
+        response = responses[node]
         if response.is_a?(String)
           begin
-            result[:response] = JSON.parse(response)
+            JSON.parse(response)
           rescue JSON::ParserError
-            result[:response] = response
+            response
           end
         else
-          result[:response] = response
+          response
         end
+      else
+        response
       end
-      result
     end
 
-    def live_nodes
-      ensure_serf
-      nodes = {}
-      result = run_once("members", "-format", "json")
-      result[:result] = JSON.parse(result[:result])
-      members = result[:result]
+    def update_cluster_state
+      path = Path.cluster_state
+      new_state = current_cluster_state
+      file_contents = JSON.pretty_generate(new_state)
+      SafeFileWriter.write(path) do |output, file|
+        output.puts(file_contents)
+        @service_installation.ensure_correct_file_permission(file)
+      end
+    end
+
+    def current_members
+      raw_response = run_command("members", "-format", "json")
+      response = JSON.parse(raw_response)
+      response["members"]
+    end
+
+    def current_cluster_state
       current_cluster_id = cluster_id
-      members["members"].each do |member|
-        if member["status"] == "alive" and
-           member["tags"]["cluster_id"] == current_cluster_id
-          nodes[member["name"]] = {
-            "serfAddress" => member["addr"],
-            "tags"        => member["tags"],
-          }
+      nodes = {}
+      unprocessed_messages_existence = {}
+      current_members.each do |member|
+        foreign = member["tags"][Tag.cluster_id] != current_cluster_id
+        next if foreign
+
+        member["tags"].each do |key, value|
+          next unless Tag.have_unprocessed_messages_tag?(key)
+          node_name = Tag.extract_node_name_from_have_unprocessed_messages_tag(key)
+          next if unprocessed_messages_existence[node_name]
+          unprocessed_messages_existence[node_name] = value == "true"
         end
+
+        nodes[member["name"]] = {
+          "type" => member["tags"][Tag.node_type],
+          "role" => member["tags"][Tag.node_role],
+          "internal_name" => member["tags"][Tag.internal_node_name],
+          "accept_messages_newer_than" => member["tags"][Tag.accept_messages_newer_than],
+          "live" => member["status"] == "alive",
+        }
+      end
+      unprocessed_messages_existence.each do |node_name, have_messages|
+        nodes[node_name]["have_unprocessed_messages"] = have_messages
+      end
+      sorted_nodes = {}
+      nodes.keys.sort.each do |key|
+        sorted_nodes[key] = nodes[key]
+      end
+      sorted_nodes
+    end
+
+    def get_tag(name)
+      myself = current_members.find do |member|
+        member["name"] == @name.to_s
+      end
+      if myself
+        myself["tags"][name]
+      else
+        nil
       end
-      nodes
     end
 
     def set_tag(name, value)
-      ensure_serf
-      run_once("tags", "-set", "#{name}=#{value}")
+      run_command("tags", "-set", "#{name}=#{value}")
+      @tags_cache[name] = value
+    end
+
+    def delete_tag(name)
+      run_command("tags", "-delete", name)
+      @tags_cache.delete(name)
     end
 
     def update_cluster_id
-      set_tag("cluster_id", cluster_id)
+      set_tag(Tag.cluster_id, cluster_id)
+    end
+
+    def set_have_unprocessed_messages_for(node_name)
+      tag = Tag.have_unprocessed_messages_tag_for(node_name)
+      set_tag(tag, true) unless @tags_cache.key?(tag)
+    end
+
+    def reset_have_unprocessed_messages_for(node_name)
+      delete_tag(Tag.have_unprocessed_messages_tag_for(node_name))
+    end
+
+    def role
+      NodeRole.normalize(get_tag(Tag.node_role))
+    end
+
+    def role=(new_role)
+      role = NodeRole.normalize(new_role)
+      set_tag(Tag.node_role, role)
+      # after that you must run update_cluster_state to update the cluster information cache
+      role
+    end
+
+    def last_message_timestamp
+      response = send_query("report_last_message_timestamp",
+                            "node" => @name.to_s)
+      if response
+        response["timestamp"]
+      else
+        nil
+      end
+    end
+
+    def accept_messages_newer_than_timestamp
+      get_tag(Tag.accept_messages_newer_than)
+    end
+
+    def accept_messages_newer_than(timestamp)
+      set_tag(Tag.accept_messages_newer_than, timestamp)
+      # after that you must run update_cluster_state to update the cluster information cache
     end
 
     def cluster_id
-      loader = CatalogLoader.new(Path.catalog.to_s)
+      loader = Catalog::Loader.new(Path.catalog.to_s)
       catalog = loader.load
       catalog.cluster_id
     end
 
+    CHECK_RESTARTED_INTERVAL = 3
+    CHECK_RESTARTED_TIMEOUT = 60 * 5
+
+    def ensure_restarted(*nodes, &block)
+      nodes << @name.to_s if nodes.empty?
+
+      targets = nodes.collect do |node|
+        serf = self.class.new(node)
+        {
+          :serf          => serf,
+          :previous_name => serf.get_tag(Tag.internal_node_name),
+        }
+      end
+
+      start_time = Time.now
+
+      yield # the given operation must restart the service.
+
+      while Time.now - start_time < CHECK_RESTARTED_TIMEOUT
+        puts "Checking nodes are restarted or not:" if @verbose
+        targets.reject! do |target|
+          name = target[:serf].get_tag(Tag.internal_node_name)
+          restarted = name != target[:previous_name]
+          puts "  #{name} vs #{target[:previous_name]} => " +
+                 "#{restarted ? "restarted" : "not yet"}" if @verbose
+          restarted
+        end
+        break if targets.empty?
+        sleep(CHECK_RESTARTED_INTERVAL)
+      end
+
+      targets.empty?
+    end
+
     private
     def ensure_serf
-      @serf = find_system_serf
-      return if @serf
+      @serf_command ||= find_system_serf
+      return if @serf_command
 
-      serf_path = self.class.path
-      @serf = serf_path.to_s
+      serf_path = Path.serf_command
+      @serf_command = serf_path.to_s
       return if serf_path.executable?
-      downloader = SerfDownloader.new(serf_path)
+      downloader = Downloader.new(serf_path)
       downloader.download
     end
 
@@ -180,19 +275,13 @@ module Droonga
       nil
     end
 
-    def run(command, *options)
-      process = SerfProcess.new(@loop, @serf, command,
-                                "-rpc-addr", rpc_address,
-                                *options)
-      process.start
-      process
-    end
-
-    def run_once(command, *options)
-      process = SerfProcess.new(@loop, @serf, command,
-                                "-rpc-addr", rpc_address,
-                                *options)
-      process.run_once
+    def run_command(command, *options)
+      ensure_serf
+      command = Command.new(@serf_command, command,
+                            "-rpc-addr", rpc_address,
+                            *options)
+      command.verbose = @verbose
+      command.run
     end
 
     def additional_options_from_payload(payload)
@@ -204,192 +293,34 @@ module Droonga
     end
 
     def extract_host(node_name)
-      node_name.split(":").first
-    end
-
-    def log_level
-      level = Logger::Level.default
-      case level
-      when "trace", "debug", "info", "warn"
-        level
-      when "error", "fatal"
-        "err"
-      else
-        level # Or error?
-      end
+      node_name.to_s.split(":").first
     end
 
     def rpc_address
-      "#{extract_host(@name)}:7373"
-    end
-
-    def node_status
-      @node_status ||= NodeStatus.new
+      "#{@name.host}:#{rpc_port}"
     end
 
-    def role
-      if node_status.have?(:role)
-        role = node_status.get(:role).to_sym
-        if self.class::ROLE.key?(role)
-          return role
-        end
-      end
-      :default
+    def rpc_port
+      7373
     end
 
-    def port
-      self.class::ROLE[role][:port]
+    def agent_port
+      Agent::PORT
     end
 
     def detect_other_hosts
-      loader = CatalogLoader.new(Path.catalog.to_s)
+      loader = Catalog::Loader.new(Path.catalog.to_s)
       catalog = loader.load
       other_nodes = catalog.all_nodes.reject do |node|
-        node == @name
+        node == @name.to_s
       end
       other_nodes.collect do |node|
-        extract_host(node)
+        NodeName.parse(node).host
       end
     end
 
     def log_tag
       "serf"
     end
-
-    class SerfProcess
-      include Loggable
-
-      def initialize(loop, serf, command, *options)
-        @loop = loop
-        @serf = serf
-        @command = command
-        @options = options
-        @pid = nil
-      end
-
-      def start
-        capture_output do |output_write, error_write|
-          env = {}
-          spawn_options = {
-            :out => output_write,
-            :err => error_write,
-          }
-          @pid = spawn(env, @serf, @command, *@options, spawn_options)
-        end
-      end
-
-      def stop
-        return if @pid.nil?
-        Process.waitpid(@pid)
-        @output_io.close
-        @error_io.close
-        @pid = nil
-      end
-
-      def running?
-        not @pid.nil?
-      end
-
-      def run_once
-        stdout, stderror, status = Open3.capture3(@serf, @command, *@options, :pgroup => true)
-        {
-          :result => stdout,
-          :error  => stderror,
-          :status => status,
-        }
-      end
-
-      private
-      def capture_output
-        result = nil
-        output_read, output_write = IO.pipe
-        error_read, error_write = IO.pipe
-
-        begin
-          result = yield(output_write, error_write)
-        rescue
-          output_read.close  unless output_read.closed?
-          output_write.close unless output_write.closed?
-          error_read.close   unless error_read.closed?
-          error_write.close  unless error_write.closed?
-          raise
-        end
-
-        output_line_buffer = LineBuffer.new
-        on_read_output = lambda do |data|
-          on_standard_output(output_line_buffer, data)
-        end
-        @output_io = Coolio::IO.new(output_read)
-        @output_io.on_read do |data|
-          on_read_output.call(data)
-        end
-        # TODO: Don't allow nil for loop. It reduces nil checks and
-        # simplifies source code.
-        @loop.attach(@output_io) if @loop
-
-        error_line_buffer = LineBuffer.new
-        on_read_error = lambda do |data|
-          on_error_output(error_line_buffer, data)
-        end
-        @error_io = Coolio::IO.new(error_read)
-        @error_io.on_read do |data|
-          on_read_error.call(data)
-        end
-        # TODO: Don't allow nil for loop. It reduces nil checks and
-        # simplifies source code.
-        @loop.attach(@error_io) if @loop
-
-        result
-      end
-
-      def on_standard_output(line_buffer, data)
-        line_buffer.feed(data) do |line|
-          line = line.chomp
-          case line
-          when /\A==> /
-            content = $POSTMATCH
-            logger.info(content)
-          when /\A    /
-            content = $POSTMATCH
-            case content
-            when /\A(\d{4})\/(\d{2})\/(\d{2}) (\d{2}):(\d{2}):(\d{2}) \[(\w+)\] /
-              year, month, day = $1, $2, $3
-              hour, minute, second = $4, $5, $6
-              level = $7
-              content = $POSTMATCH
-              level = normalize_level(level)
-              logger.send(level, content)
-            else
-              logger.info(content)
-            end
-          else
-            logger.info(line)
-          end
-        end
-      end
-
-      def normalize_level(level)
-        level = level.downcase
-        case level
-        when "err"
-          "error"
-        else
-          level
-        end
-      end
-
-      def on_error_output(line_buffer, data)
-        line_buffer.feed(data) do |line|
-          line = line.chomp
-          logger.error(line.gsub(/\A==> /, ""))
-        end
-      end
-
-      def log_tag
-        tag = "serf"
-        tag << "[#{@pid}]" if @pid
-        tag
-      end
-    end
   end
 end