procon_bypass_man 0.2.2 → 0.2.3

data/lib/procon_bypass_man/bypass/bypass_command.rb

@@ -6,13 +6,9 @@ class ProconBypassMan::BypassCommand
     RESTART = :restart
   end
 
-  def initialize(gadget:, procon:)
+  def initialize(gadget: , procon: )
     @gadget = gadget
     @procon = procon
-
-    ProconBypassMan::IOMonitor.start! if ProconBypassMan.io_monitor_logging
-    ProconBypassMan::Background::JobRunner.queue.clear # forkしたときに残留物も移ってしまうため
-    ProconBypassMan::Background::JobRunner.start!
   end
 
   def execute
@@ -29,8 +25,6 @@ class ProconBypassMan::BypassCommand
 
     # gadget => procon
     # 遅くていい
-    monitor1 = ProconBypassMan::IOMonitor.new(label: "switch -> procon")
-    monitor2 = ProconBypassMan::IOMonitor.new(label: "procon -> switch")
     ProconBypassMan.logger.info "Thread1を起動します"
 
     cycle_sleep = ProconBypassMan::CycleSleep.new(cycle_interval: 1, execution_cycle: ProconBypassMan.config.bypass_mode.gadget_to_procon_interval)
@@ -38,16 +32,15 @@ class ProconBypassMan::BypassCommand
     t1 = Thread.new do
       if ProconBypassMan.config.bypass_mode.mode == ProconBypassMan::BypassMode::TYPE_AGGRESSIVE
         ProconBypassMan.logger.info "TYPE_AGGRESSIVEなのでThread1を終了します"
-        monitor1.shutdown
         next
       end
 
+      bypass = ProconBypassMan::Bypass::SwitchToProcon.new(gadget: @gadget, procon: @procon)
       loop do
         break if $will_terminate_token
 
         cycle_sleep.sleep_or_execute do
-          bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor1)
-          bypass.send_gadget_to_procon!
+          bypass.run
         end
       rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN => e
         ProconBypassMan::SendErrorCommand.execute(error: "Switchとの切断されました.終了処理を開始します. #{e.full_message}")
@@ -63,9 +56,8 @@ class ProconBypassMan::BypassCommand
 
     # procon => gadget
     # シビア
-    ProconBypassMan.logger.info "Thread2を起動します"
     t2 = Thread.new do
-      bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor2)
+      bypass = ProconBypassMan::Bypass::ProconToSwitch.new(gadget: @gadget, procon: @procon)
       loop do
         if $will_terminate_token
           if $will_terminate_token == WILL_TERMINATE_TOKEN::TERMINATE
@@ -74,7 +66,7 @@ class ProconBypassMan::BypassCommand
           break
         end
 
-        bypass.send_procon_to_gadget!
+        bypass.run
       rescue EOFError => e
         ProconBypassMan::SendErrorCommand.execute(error: "Proconが切断されました。終了処理を開始します. #{e.full_message}")
         Process.kill "TERM", Process.ppid
@@ -84,7 +76,6 @@ class ProconBypassMan::BypassCommand
         Process.kill "TERM", Process.ppid
         break
       end
-      ProconBypassMan.logger.info "Thread2を終了します"
     end
 
     ProconBypassMan.logger.info "子プロセスでgraceful shutdownの準備ができました"
@@ -93,7 +84,7 @@ class ProconBypassMan::BypassCommand
         signal = readable_io.first[0].gets.strip
         handle_signal(signal)
       end
-    rescue ProconBypassMan::Runner::InterruptForRestart
+    rescue ProconBypassMan::InterruptForRestart
       $will_terminate_token = WILL_TERMINATE_TOKEN::RESTART
       [t1, t2].each(&:join)
       @gadget&.close

data/lib/procon_bypass_man/bypass/bypass_value.rb

@@ -0,0 +1,6 @@
+class ProconBypassMan::Bypass::BypassValue < Struct.new(:binary)
+  def to_text
+    return unless binary
+    binary.unpack.first
+  end
+end

data/lib/procon_bypass_man/bypass/procon_to_switch.rb

@@ -0,0 +1,107 @@
+require "procon_bypass_man/bypass/bypass_command"
+
+class ProconBypassMan::Bypass::ProconToSwitch
+  extend ProconBypassMan::CallbacksRegisterable
+  include ProconBypassMan::Callbacks
+
+  class CouldNotReadFromProconError < StandardError; end
+  class CouldNotWriteToSwitchError < StandardError; end
+
+  define_callbacks :run
+  set_callback :run, :after, :log_after_run
+
+  register_callback_module(ProconBypassMan::ProconDisplay::BypassHook)
+
+  attr_accessor :gadget, :procon, :bypass_value, :procon_binary_queue
+
+  def initialize(gadget: , procon: )
+    self.gadget = gadget
+    self.procon = procon
+  end
+
+  # @raise [Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN, Errno::ETIMEDOUT]
+  # @return [void]
+  def run
+    ProconBypassMan::Procon::PerformanceMeasurement.measure do |measurement|
+      self.bypass_value = ProconBypassMan::Bypass::BypassValue.new(nil)
+
+      next(run_callbacks(:run) {
+        next(false) if $will_terminate_token
+
+        raw_output = nil
+        measurement.record_read_time do
+          begin
+            ProconBypassMan::GC.stop_gc_in do
+              return(false) if $will_terminate_token
+              raw_output = self.procon.read_nonblock(64)
+            end
+          rescue IO::EAGAINWaitReadable
+            sleep(0.002)
+            retry
+          rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN, Errno::ETIMEDOUT => e
+            return(false) if $will_terminate_token
+            raise
+          end
+        end
+
+        self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_output)
+
+        result = ProconBypassMan::GC.stop_gc_in do
+          result = measurement.record_write_time do
+            begin
+              ProconBypassMan::Retryable.retryable(tries: 5, on_no_retry: [Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN, Errno::ETIMEDOUT]) do
+                begin
+                  # 終了処理を希望されているのでブロックを無視してメソッドを抜けてOK
+                  return(false) if $will_terminate_token # rubocop:disable Lint/NoReturnInBeginEndBlocks
+                  self.gadget.write_nonblock(
+                    ProconBypassMan::Processor.new(bypass_value.binary).process
+                  )
+                  next(true)
+                rescue IO::EAGAINWaitReadable
+                  return(false) if $will_terminate_token # rubocop:disable Lint/NoReturnInBeginEndBlocks
+                  measurement.record_write_error
+                  raise CouldNotWriteToSwitchError
+                rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN, Errno::ETIMEDOUT => e
+                  return(false) if $will_terminate_token # rubocop:disable Lint/NoReturnInBeginEndBlocks
+                  raise
+                end
+              end
+            rescue CouldNotWriteToSwitchError
+              next(false)
+            end
+          end
+
+          next(result)
+        end
+
+        next(result)
+      })
+    end
+  end
+
+  # @return [void]
+  def direct_connect_switch_via_bluetooth
+    ProconBypassMan.logger.debug { "direct_connect_switch_via_bluetooth!" }
+    self.procon.write_nonblock(["010500000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["010600000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["010700000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["010800000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["8005"].pack("H*"))
+    self.procon.write_nonblock(["8005"].pack("H*"))
+    self.procon.write_nonblock(["8005"].pack("H*"))
+  end
+
+  private
+
+  def log_after_run
+    return unless bypass_value.to_text
+
+    if ProconBypassMan.config.verbose_bypass_log
+      ProconBypassMan.logger.debug { "<<< #{bypass_value.to_text}" }
+    else
+      ProconBypassMan.cache.fetch key: 'bypass_log', expires_in: 1 do
+        ProconBypassMan.logger.debug { "<<< #{bypass_value.to_text}" }
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/bypass/switch_to_procon.rb

@@ -0,0 +1,64 @@
+require "procon_bypass_man/bypass/bypass_command"
+
+class ProconBypassMan::Bypass::SwitchToProcon
+  include ProconBypassMan::Callbacks
+
+  define_callbacks :run
+  set_callback :run, :after, :log_after_run
+
+  attr_accessor :gadget, :procon, :bypass_value
+
+  def initialize(gadget: , procon: )
+    self.gadget = gadget
+    self.procon = procon
+  end
+
+  # ゆっくりでいい
+  def run
+    self.bypass_value = ProconBypassMan::Bypass::BypassValue.new(nil)
+
+    run_callbacks(:run) do
+      next if $will_terminate_token
+
+      raw_input = nil
+      begin
+        raw_input = self.gadget.read_nonblock(64)
+        self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_input)
+      rescue IO::EAGAINWaitReadable
+        next
+      end
+
+      if self.bypass_value.binary
+        begin
+          raw_data =
+            case
+            when self.bypass_value.binary.rumble_data? # TODO そもそも無効になっているので消していい
+              binary = ProconBypassMan::RumbleBinary.new(binary: self.bypass_value.binary.raw)
+              binary.noop!
+              binary.raw
+            else
+              self.bypass_value.binary.raw
+            end
+          # バイブレーションを無効にしているのでおそらく書き込む必要はない
+          # self.procon.write_nonblock(raw_data)
+        rescue IO::EAGAINWaitReadable
+          next
+        end
+      end
+    end
+  end
+
+  private
+
+  def log_after_run
+    return unless bypass_value.to_text
+
+    if ProconBypassMan.config.verbose_bypass_log
+      ProconBypassMan.logger.debug { ">>> #{bypass_value.to_text}" }
+    else
+      ProconBypassMan.cache.fetch key: 'bypass_log', expires_in: 1 do
+        ProconBypassMan.logger.debug { ">>> #{bypass_value.to_text}" }
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/bypass.rb

@@ -1,111 +1,6 @@
-require "procon_bypass_man/bypass/usb_hid_logger"
-require "procon_bypass_man/bypass/bypass_command"
-
-class ProconBypassMan::Bypass
-  extend ProconBypassMan::CallbacksRegisterable
-
-  register_callback_module(ProconBypassMan::Bypass::UsbHidLogger)
-  register_callback_module(ProconBypassMan::ProconDisplay::BypassHook)
-
-  class BypassValue < Struct.new(:binary)
-    def to_text
-      return unless binary
-      binary.unpack.first
-    end
-  end
-
-  attr_accessor :gadget, :procon, :monitor, :bypass_value
-
-  def initialize(gadget: , procon: , monitor: )
-    self.gadget = gadget
-    self.procon = procon
-    self.monitor = monitor
-  end
-
-  # ゆっくりでいい
-  def send_gadget_to_procon!
-    monitor.record(:start_function)
-    self.bypass_value = BypassValue.new(nil)
-
-    run_callbacks(:send_gadget_to_procon) do
-      break if $will_terminate_token
+module ProconBypassMan::Bypass; end
 
-      raw_input = nil
-      begin
-        raw_input = self.gadget.read_nonblock(64)
-        self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_input)
-      rescue IO::EAGAINWaitReadable
-        monitor.record(:eagain_wait_readable_on_read)
-      end
-
-      if self.bypass_value.binary
-        begin
-          raw_data =
-            case
-            when self.bypass_value.binary.rumble_data?
-              binary = ProconBypassMan::RumbleBinary.new(binary: self.bypass_value.binary.raw)
-              binary.noop!
-              binary.raw
-            else
-              self.bypass_value.binary.raw
-            end
-          self.procon.write_nonblock(raw_data)
-        rescue IO::EAGAINWaitReadable
-          monitor.record(:eagain_wait_readable_on_write)
-          break
-        end
-      end
-    end
-
-    monitor.record(:end_function)
-  end
-
-  def send_procon_to_gadget!
-    monitor.record(:start_function)
-    self.bypass_value = BypassValue.new(nil)
-
-    run_callbacks(:send_procon_to_gadget) do
-      break if $will_terminate_token
-
-      begin
-        Timeout.timeout(1) do
-          raw_output = self.procon.read(64)
-          self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_output)
-        end
-      rescue Timeout::Error
-        ProconBypassMan.logger.debug { "read timeout! do sleep. by send_procon_to_gadget!" }
-        ProconBypassMan.error_logger.error { "read timeout! do sleep. by send_procon_to_gadget!" }
-        ProconBypassMan::SendErrorCommand.execute(error: "read timeout! do sleep. by send_procon_to_gadget!")
-        monitor.record(:eagain_wait_readable_on_read)
-        retry
-      rescue IO::EAGAINWaitReadable
-        ProconBypassMan.logger.debug { "EAGAINWaitReadable" }
-        monitor.record(:eagain_wait_readable_on_read)
-        sleep(0.005)
-        retry
-      end
-
-      begin
-        self.gadget.write_nonblock(
-          ProconBypassMan::Processor.new(bypass_value.binary).process
-        )
-      rescue IO::EAGAINWaitReadable
-        monitor.record(:eagain_wait_readable_on_write)
-        break
-      end
-    end
-    monitor.record(:end_function)
-  end
-
-  # @return [void]
-  def direct_connect_switch_via_bluetooth
-    ProconBypassMan.logger.debug { "direct_connect_switch_via_bluetooth!" }
-    self.procon.write_nonblock(["010500000000000000003800"].pack("H*")) # home led off
-    self.procon.write_nonblock(["010600000000000000003800"].pack("H*")) # home led off
-    self.procon.write_nonblock(["010700000000000000003800"].pack("H*")) # home led off
-    self.procon.write_nonblock(["010800000000000000003800"].pack("H*")) # home led off
-    self.procon.write_nonblock(["8005"].pack("H*"))
-    self.procon.write_nonblock(["8005"].pack("H*"))
-    self.procon.write_nonblock(["8005"].pack("H*"))
-  end
-end
+require "procon_bypass_man/bypass/bypass_command"
+require "procon_bypass_man/bypass/bypass_value"
+require "procon_bypass_man/bypass/procon_to_switch"
+require "procon_bypass_man/bypass/switch_to_procon"

data/lib/procon_bypass_man/configuration.rb

@@ -47,14 +47,15 @@ class ProconBypassMan::Configuration
     def fallback_setting_path
       "/tmp/procon_bypass_man_fallback_setting.yaml"
     end
-
-    def io_monitor_logging
-      config.io_monitor_logging
-    end
   end
 
   attr_accessor :enable_critical_error_logging
-  attr_writer :verbose_bypass_log, :raw_setting, :enable_reporting_pressed_buttons, :never_exit_accidentally, :io_monitor_logging, :enable_home_led_on_connect
+  attr_writer :verbose_bypass_log, :raw_setting, :never_exit_accidentally, :enable_home_led_on_connect
+  # 削除予定
+  attr_writer :enable_reporting_pressed_buttons
+
+  # NOTE 非推奨. 削除したいが設定ファイルに残っているときにエラーにしたくないので互換性維持のため残す
+  attr_writer :io_monitor_logging
 
   def root=(path)
     @root = path
@@ -114,35 +115,14 @@ class ProconBypassMan::Configuration
     "#{root}/.setting_yaml_digest"
   end
 
-  # @return [String] pbm-webの接続先
-  def internal_api_servers
-    if !!ENV["INTERNAL_API_SERVER"]
-      [ENV["INTERNAL_API_SERVER"]]
-    else
-      [ 'http://localhost:9090',
-        'http://localhost:8080',
-      ].compact
-    end
-  end
-
-  # @return [Array<ProconBypassMan::ServerPool>]
-  def internal_server_pool
-    @internal_server_pool ||= ProconBypassMan::ServerPool.new(servers: internal_api_servers)
-  end
-
-  # @return [Array<ProconBypassMan::ServerPool>]
-  def server_pool
-    @server_pool ||= ProconBypassMan::ServerPool.new(servers: api_servers)
-  end
-
   # @return [String, NilClass]
-  def current_server
-    server_pool.server
+  def api_server
+    api_servers&.first
   end
 
   # @return [String, NilClass]
   def current_ws_server
-    if (uri = URI.parse(server_pool.server))
+    if (uri = URI.parse(api_server))
       if uri.port == 443
         return "ws://#{uri.host}"
       else
@@ -161,7 +141,7 @@ class ProconBypassMan::Configuration
 
   # @return [Boolean]
   def enable_ws?
-    !!current_server
+    !!api_server
   end
 
   # @return [Boolean]
@@ -178,8 +158,9 @@ class ProconBypassMan::Configuration
     end
   end
 
+  # @return [Boolean]
   def has_api_server?
-    not api_servers.length.zero?
+    !!api_server
   end
 
   def verbose_bypass_log
@@ -190,19 +171,14 @@ class ProconBypassMan::Configuration
     @raw_setting ||= {}
   end
 
-  # @return [Boolean] default false
-  def enable_reporting_pressed_buttons
-    @enable_reporting_pressed_buttons ||= false
-  end
-
   # @return [Boolean] default false
   def never_exit_accidentally
     @never_exit_accidentally || false
   end
 
-  # @return [Boolean] default false
-  def io_monitor_logging
-    @io_monitor_logging ||= false
+  # @return [Boolean] プロコンから「入力にかかっている時間」と「1秒間あたり何回入力できているか」をサーバに送信する
+  def enable_procon_performance_measurement?
+    has_api_server?
   end
 
   # @return [Boolean] default true

data/lib/procon_bypass_man/device_connection/procon_setting_overrider.rb

@@ -2,17 +2,26 @@ class ProconBypassMan::DeviceConnection::ProconSettingOverrider
   attr_accessor :procon, :output_report_watcher, :output_report_generator
 
   SUB_COMMAND_HOME_LED_ON = "38"
+  SUB_COMMAND_VIBRATION = "48"
+
   SUB_COMMAND_ARG_HOME_LED_ON = "1FF0FF"
+  SUB_COMMAND_ARG_VIBRATION_OFF = "00"
+
+  ALL_SETTINGS = {
+    home_led_on: [SUB_COMMAND_HOME_LED_ON, SUB_COMMAND_ARG_HOME_LED_ON],
+    vibration_off: [SUB_COMMAND_VIBRATION, SUB_COMMAND_ARG_VIBRATION_OFF],
+  }
+
+  # TODO 自動生成する
   SPECIAL_SUB_COMMAND_ARGS =  {
     SUB_COMMAND_HOME_LED_ON => SUB_COMMAND_ARG_HOME_LED_ON,
+    SUB_COMMAND_VIBRATION => SUB_COMMAND_ARG_VIBRATION_OFF,
   }
-  SETTING_HOME_LED_ON = { home_led_on: [SUB_COMMAND_HOME_LED_ON, SUB_COMMAND_ARG_HOME_LED_ON] }
-  ALL_SETTINGS = SETTING_HOME_LED_ON
 
   def initialize(procon: )
     use_steps = {}
     if ProconBypassMan.config.enable_home_led_on_connect
-      use_steps.merge!(SETTING_HOME_LED_ON)
+      use_steps.merge!(ALL_SETTINGS)
     end
 
     @setting_steps = use_steps.keys

data/lib/procon_bypass_man/procon/macro.rb

@@ -99,7 +99,7 @@ class ProconBypassMan::Procon::Macro
 
       if nested_step.over?
         steps.shift # NestedStepを破棄する
-        self.after_callback_block.call if self.after_callback_block
+        self.after_callback_block.call if self.after_callback_block && steps.empty?
         return next_step
       else
         return nested_step.next_step

data/lib/procon_bypass_man/procon/performance_measurement/last_bypass_at.rb

@@ -0,0 +1,17 @@
+class ProconBypassMan::Procon::PerformanceMeasurement::LastBypassAt
+  include Singleton
+
+  attr_accessor :mutex, :last_bypass_at
+
+  def initialize
+    self.mutex = Mutex.new
+    self.last_bypass_at = Time.now
+  end
+
+  def self.touch(&block)
+    instance.mutex.synchronize do
+      block.call(Time.now - instance.last_bypass_at)
+      instance.last_bypass_at = Time.now
+    end
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/measurement_collection.rb

@@ -0,0 +1,9 @@
+# TODO SpanCollection にする
+class  ProconBypassMan::Procon::PerformanceMeasurement::MeasurementCollection
+  attr_accessor :timestamp_key, :spans
+
+  def initialize(timestamp_key: , spans: )
+    self.timestamp_key = timestamp_key
+    self.spans = spans
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/measurements_summarizer.rb

@@ -0,0 +1,84 @@
+class ProconBypassMan::Procon::PerformanceMeasurement::MeasurementsSummarizer
+  class PerformanceMetric < Struct.new(:interval_from_previous_succeed_max,
+                                       :interval_from_previous_succeed_p50,
+                                       :write_time_max,
+                                       :write_time_p50,
+                                       :read_time_max,
+                                       :read_time_p50,
+                                       :time_taken_p50,
+                                       :time_taken_p95,
+                                       :time_taken_p99,
+                                       :time_taken_max,
+                                       :read_error_count,
+                                       :write_error_count,
+                                       :gc_count,
+                                       :gc_time,
+                                       :succeed_rate); end
+
+  def initialize(spans: )
+    @spans = spans
+  end
+
+  # @return [PerformanceMetric]
+  def summarize
+    sorted_write_time = @spans.map(&:write_time).sort
+    sorted_read_time = @spans.map(&:read_time).sort
+    gc_count = @spans.map(&:gc_count).sum
+    gc_time = @spans.map(&:gc_time).sum
+
+    sorted_time_taken = @spans.select(&:succeed).map(&:time_taken).sort
+    sorted_interval_from_previous_succeed = @spans.select(&:succeed).map(&:interval_from_previous_succeed).sort
+
+    interval_from_previous_succeed_max = sorted_interval_from_previous_succeed.last || 0
+    interval_from_previous_succeed_p50 = percentile(sorted_list: sorted_interval_from_previous_succeed , percentile: 0.50)
+
+    write_time_max = sorted_write_time.last || 0
+    write_time_p50 = percentile(sorted_list: sorted_write_time , percentile: 0.50)
+
+    read_time_max = sorted_read_time.last || 0
+    read_time_p50 = percentile(sorted_list: sorted_read_time , percentile: 0.50)
+
+    time_taken_p50 = percentile(sorted_list: sorted_time_taken, percentile: 0.50)
+    time_taken_p95 = percentile(sorted_list: sorted_time_taken, percentile: 0.95)
+    time_taken_p99 = percentile(sorted_list: sorted_time_taken, percentile: 0.99)
+    time_taken_max = sorted_time_taken.last || 0
+
+    total_read_error_count = @spans.map(&:read_error_count).sum
+    total_write_error_count = @spans.map(&:write_error_count).sum
+    succeed_rate =
+      if @spans.length.zero?
+        0
+      else
+        succeed_rate = (sorted_time_taken.length / @spans.length.to_f).floor(3)
+      end
+
+    PerformanceMetric.new(interval_from_previous_succeed_max,
+                          interval_from_previous_succeed_p50,
+                          write_time_max,
+                          write_time_p50,
+                          read_time_max,
+                          read_time_p50,
+                          time_taken_p50,
+                          time_taken_p95,
+                          time_taken_p99,
+                          time_taken_max,
+                          total_read_error_count,
+                          total_write_error_count,
+                          gc_count,
+                          gc_time,
+                          succeed_rate)
+  end
+
+  private
+
+  # @param [Array<Numeric>] sorted_list
+  # @param [Float] percentile
+  # @return [Float]
+  def percentile(sorted_list: , percentile: )
+    return 0.0 if sorted_list.empty?
+    values_sorted = sorted_list
+    k = ((percentile*(values_sorted.length-1))+1).floor - 1
+    f = ((percentile*(values_sorted.length-1))+1).modulo(1)
+    return(values_sorted[k] + (f * (values_sorted[k+1] - values_sorted[k]))).floor(3)
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/procon_performance_span_transfer_job.rb

@@ -0,0 +1,8 @@
+# Bypassプロセスが収集したパフォーマンスメトリクスを、集計するためにmasterプロセスに転送するためジョブ
+class ProconBypassMan::ProconPerformanceSpanTransferJob
+  extend ProconBypassMan::Background::JobPerformable
+
+  def self.perform(spans)
+    ProconBypassMan::Procon::PerformanceMeasurement::QueueOverProcess.push(spans)
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/queue_over_process.rb

@@ -0,0 +1,38 @@
+class ProconBypassMan::Procon::PerformanceMeasurement::QueueOverProcess
+  extend ProconBypassMan::CanOverProcess
+
+  include Singleton
+
+  attr_reader :distributed_queue
+
+  # @override
+  def self.enable?
+    ProconBypassMan.config.enable_procon_performance_measurement?
+  end
+
+  # @override
+  def self.distributed_class
+    ProconBypassMan::Procon::PerformanceMeasurement::SpanQueue
+  end
+
+  # @override
+  def self.socket_file_path
+    "/tmp/procon_bypass_man_procon_performance_queue".freeze
+  end
+
+  def self.push(value)
+    return unless enable?
+
+    instance.distributed_queue.push(value)
+  end
+
+  def self.pop
+    return unless enable?
+
+    instance.distributed_queue.pop
+  end
+
+  def initialize
+    @distributed_queue = DRbObject.new_with_uri(self.class.socket_path)
+  end
+end