aws_advanced_ruby_driver_wrapper 1.0.0

data/lib/aws_advanced_ruby_driver_wrapper/plugins/blue_green/blue_green_plugin.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'concurrent'
+require_relative '../../logging'
+require_relative '../../ruby_method'
+require_relative '../../property_definition'
+require_relative '../../utils/rds_utils'
+require_relative 'phase'
+require_relative 'role'
+require_relative 'status'
+require_relative 'status_provider'
+
+module AwsAdvancedRubyDriverWrapper
+  module Plugins
+    module BlueGreen
+      class BlueGreenPlugin
+        include Logging
+
+        BLUE_GREEN_NAME = :blue_green
+
+        # When present in wrapper_props, internal_connect calls bypass BG routing.
+        # Used by BG monitoring connections to avoid being intercepted by their own plugin.
+        BG_SKIP_ROUTING_KEY = :'bg.skip_routing'
+
+        CLOSING_METHODS = Set[
+          RubyMethod::CONNECTION_CLOSE.name,
+          RubyMethod::STATEMENT_CLOSE.name
+        ].freeze
+
+        PROVIDERS = Concurrent::Map.new
+
+        def initialize(service_container, props = ::Concurrent::Map.new)
+          @service_container = service_container
+          @wrapper_props = props
+          @bgd_id = PropertyDefinition::BGD_ID.get(props).to_s.strip.downcase
+          @bg_status = nil
+          @cluster_id = nil
+          @start_time_ns = Concurrent::AtomicReference.new(0)
+          @end_time_ns = Concurrent::AtomicReference.new(0)
+
+          service_container.storage_service.register(BLUE_GREEN_NAME, ttl: 3600)
+
+          network_methods = service_container.dialect_service.driver_dialect.network_bound_methods
+          @subscribed_methods = (Set['connect', 'internal_connect'] | network_methods).freeze
+        end
+
+        attr_reader :subscribed_methods
+
+        def connect(host_info, driver_props, is_initial_connection, pipeline_callable)
+          route_connect(host_info, driver_props, is_initial_connection, pipeline_callable, is_internal: false)
+        end
+
+        def internal_connect(host_info, driver_props, wrapper_props, is_initial_connection, pipeline_callable)
+          # BG monitoring connections set BG_SKIP_ROUTING_KEY to bypass routing.
+          return pipeline_callable.call if wrapper_props[BG_SKIP_ROUTING_KEY]
+
+          route_connect(host_info, driver_props, is_initial_connection, pipeline_callable, is_internal: true)
+        end
+
+        def execute(method_name, pipeline_callable, *_, **, &)
+          reset_routing_time_ns
+
+          begin
+            init_provider
+
+            return pipeline_callable.call if CLOSING_METHODS.include?(method_name)
+
+            @bg_status = storage_service.get(BLUE_GREEN_NAME, @bgd_id)
+            if @bg_status.nil? || @bg_status.current_phase == Phase::NOT_CREATED || @bg_status.current_phase == Phase::COMPLETED
+              return pipeline_callable.call
+            end
+
+            current_host = @service_container.connection_service.current_host_info
+            host_role = @bg_status.role(current_host)
+            return pipeline_callable.call if host_role.nil?
+
+            routing = @bg_status.execute_routing.find { |r| r.match?(current_host, host_role) }
+            return pipeline_callable.call if routing.nil?
+
+            @start_time_ns.set(nano_time)
+            result = nil
+
+            while routing && result.nil?
+              result = routing.apply(method_name, @wrapper_props, storage_service)
+
+              next unless result.nil?
+
+              @bg_status = storage_service.get(BLUE_GREEN_NAME, @bgd_id)
+              if @bg_status.nil?
+                @end_time_ns.set(nano_time)
+                return pipeline_callable.call
+              end
+              routing = @bg_status.execute_routing.find { |r| r.match?(current_host, host_role) }
+            end
+
+            @end_time_ns.set(nano_time)
+            result.nil? ? pipeline_callable.call : result
+          ensure
+            @end_time_ns.set(nano_time) if @start_time_ns.get.positive? && @end_time_ns.get.zero?
+          end
+        end
+
+        def hold_time_ns
+          return 0 if @start_time_ns.get.zero?
+
+          end_ns = @end_time_ns.get
+          end_ns.zero? ? (nano_time - @start_time_ns.get) : (end_ns - @start_time_ns.get)
+        end
+
+        def reset_routing_time_ns
+          @start_time_ns.set(0)
+          @end_time_ns.set(0)
+        end
+
+        def self.clean_up_providers
+          PROVIDERS.each_key { |k| PROVIDERS.delete(k)&.stop }
+        end
+
+        private
+
+        def route_connect(host_info, driver_props, is_initial_connection, pipeline_callable, is_internal: false)
+          reset_routing_time_ns
+
+          begin
+            @bg_status = storage_service.get(BLUE_GREEN_NAME, @bgd_id)
+            return regular_connect(pipeline_callable, is_initial_connection) if @bg_status.nil?
+
+            host_role = @bg_status.role(host_info)
+            return regular_connect(pipeline_callable, is_initial_connection) if host_role.nil?
+
+            routing = @bg_status.connect_routing.find { |r| r.match?(host_info, host_role) }
+            return regular_connect(pipeline_callable, is_initial_connection) if routing.nil?
+
+            @start_time_ns.set(nano_time)
+            conn = nil
+
+            while routing && conn.nil?
+              # Pass self so a routing that opens a substitute connection can skip this plugin in the
+              # nested pipeline, preventing the connect path from re-entering BG routing (infinite recursion).
+              conn = routing.apply(host_info, driver_props, @wrapper_props, is_initial_connection, @service_container,
+                                   is_internal: is_internal, bg_plugin: self)
+
+              next unless conn.nil?
+
+              # Routing passed — re-read status in case it changed while we were waiting.
+              @bg_status = storage_service.get(BLUE_GREEN_NAME, @bgd_id)
+              if @bg_status.nil?
+                @end_time_ns.set(nano_time)
+                return regular_connect(pipeline_callable, is_initial_connection)
+              end
+              routing = @bg_status.connect_routing.find { |r| r.match?(host_info, host_role) }
+            end
+
+            @end_time_ns.set(nano_time)
+            conn ||= pipeline_callable.call
+
+            init_provider if is_initial_connection
+            conn
+          ensure
+            @end_time_ns.set(nano_time) if @start_time_ns.get.positive? && @end_time_ns.get.zero?
+          end
+        end
+
+        def regular_connect(pipeline_callable, is_initial_connection)
+          conn = pipeline_callable.call
+          init_provider if is_initial_connection
+          conn
+        end
+
+        def init_provider
+          return if @cluster_id && PROVIDERS.key?(@bgd_id)
+
+          host_list_provider = @service_container.host_service.host_list_provider
+          @cluster_id = host_list_provider.respond_to?(:cluster_id) ? host_list_provider.cluster_id :
+                          @service_container.connection_service.config.cluster_id
+          PROVIDERS.compute_if_absent(@bgd_id) do
+            StatusProvider.new(@service_container, @wrapper_props, @bgd_id, @cluster_id)
+          end
+        end
+
+        def storage_service
+          @service_container.storage_service
+        end
+
+        def nano_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        end
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/plugins/blue_green/host_mapper.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'concurrent'
+require_relative '../../host/host_info'
+require_relative '../../host/host_role'
+require_relative '../../utils/rds_utils'
+require_relative 'role'
+
+module AwsAdvancedRubyDriverWrapper
+  module Plugins
+    module BlueGreen
+      class HostMapper
+        attr_reader :corresponding_hosts, :role_by_host, :host_ip_addresses
+
+        def initialize
+          @corresponding_hosts = Concurrent::Hash.new
+          @role_by_host        = Concurrent::Hash.new
+          @host_ip_addresses   = Concurrent::Hash.new
+        end
+
+        def update(source_status, target_status)
+          @corresponding_hosts.clear
+
+          build_instance_pairs(source_status, target_status)
+          build_cluster_pairs(source_status, target_status)
+        end
+
+        def merge_ips(ip_map)
+          @host_ip_addresses.merge!(ip_map)
+        end
+
+        def register_role(host_names, role)
+          host_names.each { |x| @role_by_host[x.downcase] = role }
+        end
+
+        def clear
+          @corresponding_hosts.clear
+          @role_by_host.clear
+          @host_ip_addresses.clear
+        end
+
+        def to_debug_s
+          @corresponding_hosts.map { |k, v| "   #{k} -> #{v[1]&.host_and_port || '<null>'}" }.join("\n")
+        end
+
+        private
+
+        def build_instance_pairs(source_status, target_status)
+          return unless source_status&.start_topology&.any? && target_status&.start_topology&.any?
+
+          blue_writer  = writer_host(source_status)
+          green_writer = writer_host(target_status)
+          blue_readers  = reader_hosts(source_status)
+          green_readers = reader_hosts(target_status)
+
+          @corresponding_hosts[blue_writer.host] = [blue_writer, green_writer] if blue_writer
+
+          return unless blue_readers&.any?
+
+          if green_readers&.any?
+            blue_readers.each_with_index do |blue, i|
+              @corresponding_hosts[blue.host] = [blue, green_readers[i % green_readers.size]]
+            end
+          else
+            blue_readers.each { |blue| @corresponding_hosts[blue.host] = [blue, green_writer] }
+          end
+        end
+
+        def build_cluster_pairs(source_status, target_status)
+          return unless source_status&.host_names&.any? && target_status&.host_names&.any?
+
+          blue_hosts  = source_status.host_names
+          green_hosts = target_status.host_names
+
+          pair_by_dns_type(blue_hosts, green_hosts, :writer_cluster_dns?)
+          pair_by_dns_type(blue_hosts, green_hosts, :reader_cluster_dns?)
+          pair_custom_clusters(blue_hosts, green_hosts)
+        end
+
+        def pair_by_dns_type(blue_hosts, green_hosts, dns_method)
+          blue  = blue_hosts.find  { |h| Utils::RdsUtils.public_send(dns_method, h) }
+          green = green_hosts.find { |h| Utils::RdsUtils.public_send(dns_method, h) }
+          return unless blue && green
+
+          @corresponding_hosts[blue] ||= [Host::HostInfo.new(host: blue), Host::HostInfo.new(host: green)]
+        end
+
+        def pair_custom_clusters(blue_hosts, green_hosts)
+          blue_hosts.select { |h| Utils::RdsUtils.rds_custom_cluster_dns?(h) }.each do |blue_host|
+            custom_name = Utils::RdsUtils.rds_cluster_id(blue_host)
+            next unless custom_name
+
+            green_host = green_hosts.find do |x|
+              Utils::RdsUtils.rds_custom_cluster_dns?(x) &&
+                custom_name == Utils::RdsUtils.remove_green_instance_prefix(Utils::RdsUtils.rds_cluster_id(x))
+            end
+            next unless green_host
+
+            @corresponding_hosts[blue_host] ||= [
+              Host::HostInfo.new(host: blue_host),
+              Host::HostInfo.new(host: green_host)
+            ]
+          end
+        end
+
+        def writer_host(interim_status)
+          interim_status.start_topology&.find { |x| x.role == Host::HostRole::WRITER }
+        end
+
+        def reader_hosts(interim_status)
+          interim_status.start_topology
+                        &.reject { |x| x.role == Host::HostRole::WRITER }
+                        &.sort_by(&:host)
+        end
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/plugins/blue_green/iam_host_tracker.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'concurrent'
+require_relative '../../logging'
+
+module AwsAdvancedRubyDriverWrapper
+  module Plugins
+    module BlueGreen
+      # Tracks which green host have successfully connected using a non-prefixed (blue) IAM hostname,
+      # indicating the host has completed its DNS rename.
+      class IamHostTracker
+        include Logging
+
+        attr_reader :green_host_change_name_times
+
+        def initialize(on_all_changed:)
+          @successful_connects = Concurrent::Hash.new
+          @green_host_change_name_times = Concurrent::Hash.new
+          @all_changed                 = Concurrent::AtomicBoolean.new(false)
+          @on_all_changed              = on_all_changed
+        end
+
+        def register(connect_host, iam_host)
+          names_differ = connect_host && connect_host != iam_host
+
+          if names_differ && !connected?(connect_host, iam_host)
+            @green_host_change_name_times[connect_host] ||= Time.now
+            logger.debug { "Green host '#{connect_host}' has changed its name to '#{iam_host}'." }
+          end
+
+          (@successful_connects[connect_host] ||= Set.new).add(iam_host)
+
+          return unless names_differ
+
+          all_changed = @successful_connects
+                        .reject { |_, v| v.empty? }
+                        .all? { |k, v| v.any? { |y| k != y } }
+
+          return unless all_changed && !@all_changed.true?
+
+          logger.debug { 'All green hosts changed' }
+          @all_changed.make_true
+          @on_all_changed&.call
+        end
+
+        def connected?(connect_host, iam_host)
+          @successful_connects[connect_host]&.include?(iam_host) || false
+        end
+
+        def all_changed?
+          @all_changed.true?
+        end
+
+        def size
+          @successful_connects.size
+        end
+
+        def clear
+          @green_host_change_name_times.clear
+          @all_changed.make_false
+          @successful_connects.clear
+        end
+
+        def to_debug_s
+          @green_host_change_name_times.map { |k, v| "   #{k} -> #{v}" }.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/plugins/blue_green/interim_status.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module AwsAdvancedRubyDriverWrapper
+  module Plugins
+    module BlueGreen
+      InterimStatus = Struct.new(
+        :blue_green_phase,
+        :version,
+        :port,
+        :start_topology,
+        :current_topology,
+        :start_ip_addresses_by_host,
+        :current_ip_addresses_by_host,
+        :host_names,
+        :all_start_topology_ip_changed,
+        :all_start_topology_endpoints_removed,
+        :all_topology_changed
+      ) do
+        def to_s
+          start_ip_map     = format_map(start_ip_addresses_by_host)
+          current_ip_map   = format_map(current_ip_addresses_by_host)
+          host_names_str   = host_names&.join("\n   ")
+          start_topo_str   = log_topology(start_topology)
+          current_topo_str = log_topology(current_topology)
+
+          <<~STATUS
+            InterimStatus [
+             phase #{blue_green_phase || '<null>'},
+             version '#{version}',
+             port #{port},
+             host_names:
+               #{blank?(host_names_str) ? '-' : host_names_str}
+             Start #{blank?(start_topo_str) ? '-' : start_topo_str}
+             Start IP map:
+               #{blank?(start_ip_map) ? '-' : start_ip_map}
+             Current #{blank?(current_topo_str) ? '-' : current_topo_str}
+             Current IP map:
+               #{blank?(current_ip_map) ? '-' : current_ip_map}
+             all_start_topology_ip_changed: #{all_start_topology_ip_changed}
+             all_start_topology_endpoints_removed: #{all_start_topology_endpoints_removed}
+             all_topology_changed: #{all_topology_changed}
+            ]
+          STATUS
+        end
+
+        def hash
+          [blue_green_phase, version, port, all_start_topology_ip_changed,
+           all_start_topology_endpoints_removed, all_topology_changed,
+           host_names&.sort, topology_hash_str(start_topology),
+           topology_hash_str(current_topology), ip_map_hash_str(start_ip_addresses_by_host),
+           ip_map_hash_str(current_ip_addresses_by_host)].hash
+        end
+
+        private
+
+        def format_map(map)
+          map&.map { |k, v| "#{k} -> #{v}" }&.join("\n   ").to_s
+        end
+
+        def log_topology(topology)
+          topology&.map { |h| "#{h.host_and_port} #{h.role}" }&.join(', ').to_s
+        end
+
+        def topology_hash_str(topology)
+          topology&.map { |h| "#{h.host_and_port}#{h.role}" }&.sort&.join(',').to_s
+        end
+
+        def ip_map_hash_str(map)
+          map&.map { |k, v| "#{k}#{v}" }&.sort&.join(',').to_s
+        end
+
+        def blank?(str)
+          str.nil? || str.empty?
+        end
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/plugins/blue_green/interval_rate.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module AwsAdvancedRubyDriverWrapper
+  module Plugins
+    module BlueGreen
+      module IntervalRate
+        BASELINE  = :baseline
+        INCREASED = :increased
+        HIGH      = :high
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/plugins/blue_green/phase.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module AwsAdvancedRubyDriverWrapper
+  module Plugins
+    module BlueGreen
+      class Phase
+        include Comparable
+
+        attr_reader :value, :name
+
+        def initialize(value, active_switchover_or_completed, name)
+          @value = value
+          @active_switchover_or_completed = active_switchover_or_completed
+          @name = name
+        end
+        private_class_method :new
+
+        NOT_CREATED = new(0, false, 'NOT_CREATED')
+        CREATED     = new(1, false, 'CREATED')
+        PREPARATION = new(2, true,  'PREPARATION')
+        IN_PROGRESS = new(3, true,  'IN_PROGRESS')
+        POST        = new(4, true,  'POST')
+        COMPLETED   = new(5, true,  'COMPLETED')
+
+        STATUS_MAPPING = {
+          'AVAILABLE' => CREATED,
+          'SWITCHOVER_INITIATED' => PREPARATION,
+          'SWITCHOVER_IN_PROGRESS' => IN_PROGRESS,
+          'SWITCHOVER_IN_POST_PROCESSING' => POST,
+          'SWITCHOVER_COMPLETED' => COMPLETED
+        }.freeze
+
+        def self.parse_phase(value)
+          return NOT_CREATED if value.nil? || value.empty?
+
+          STATUS_MAPPING.fetch(value.upcase) do
+            raise ArgumentError, "Unknown Blue/Green status: #{value}"
+          end
+        end
+
+        def active_switchover_or_completed?
+          @active_switchover_or_completed
+        end
+
+        def to_s
+          @name
+        end
+
+        def <=>(other)
+          value <=> other.value
+        end
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/plugins/blue_green/phase_event_log.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'concurrent'
+require_relative 'phase'
+require_relative 'phase_time_info'
+
+module AwsAdvancedRubyDriverWrapper
+  module Plugins
+    module BlueGreen
+      # Ordered log of timestamped events during a switchover (phase transitions, DNS changes,
+      # monitor resets). Used to produce the final switchover summary printed at completion.
+      class PhaseEventLog
+        def initialize
+          @entries = Concurrent::Hash.new
+        end
+
+        # Records an event with the current wall-clock and monotonic timestamps.
+        # Only the first occurrence of each label is kept (idempotent).
+        def record(label, rollback_suffix, phase: nil)
+          @entries["#{label}#{rollback_suffix}"] ||= PhaseTimeInfo.new(Time.now, nano_time, phase)
+        end
+
+        def clear
+          @entries.clear
+        end
+
+        def any?(&)
+          @entries.any?(&)
+        end
+
+        # Formats a human-readable switchover summary table with timestamps and ms offsets
+        # relative to the IN_PROGRESS (or PREPARATION for rollback) phase start time.
+        def summary(bgd_id, rollback)
+          left_pad = 5
+          default_field = 31
+          max_name_len = @entries.keys.map { |k| k.length + left_pad }.max || default_field
+
+          time_zero_phase = rollback ? Phase::PREPARATION : Phase::IN_PROGRESS
+          suffix = rollback ? ' (rollback)' : ''
+          time_zero = @entries["#{time_zero_phase}#{suffix}"] || (rollback && @entries[time_zero_phase.to_s])
+
+          divider = "---------------------------------------------------#{'-' * max_name_len}\n"
+          status_label = rollback ? 'ROLLED BACK' : 'COMPLETED'
+
+          header = "#{'timestamp'.ljust(28)} #{'time offset (ms)'.rjust(21)} #{'event'.rjust(max_name_len)}"
+
+          rows = @entries
+                 .sort_by { |_, v| v.timestamp_nano }
+                 .map do |k, v|
+                   offset = time_zero ? ((v.timestamp_nano - time_zero.timestamp_nano) / 1_000_000) : ''
+                   "#{v.timestamp.to_s.rjust(28)} #{offset.to_s.rjust(18)} ms #{k.rjust(max_name_len)}"
+                 end
+            .join("\n")
+
+          "[bgd_id: '#{bgd_id}'] Blue/Green Deployment Switchover #{status_label}\n" \
+            "#{divider}#{header}\n#{divider}#{rows}\n#{divider}"
+        end
+
+        def to_debug_s
+          @entries.map { |k, v| "   #{k} -> #{v.timestamp}" }.join("\n")
+        end
+
+        private
+
+        def nano_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        end
+      end
+    end
+  end
+end