neo4j-ruby-driver 1.7.4 → 4.4.0

data/ruby/neo4j/driver/internal/messaging/v3/bolt_protocol_v3.rb

@@ -0,0 +1,82 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V3
+        class BoltProtocolV3
+          VERSION = BoltProtocolVersion.new(3, 0)
+          INSTANCE = new
+          METADATA_EXTRACTOR = Util::MetadataExtractor.new(:t_first, :t_last)
+
+          def create_message_format
+            MessageFormatV3.new
+          end
+
+          def initialize_channel(channel, user_agent, auth_token, routing_context)
+            message = Request::HelloMessage.new(user_agent, auth_token,
+                                                (routing_context.to_h if routing_context.server_routing_enabled?))
+            handler = Handlers::HelloResponseHandler.new(channel, VERSION)
+
+            channel.message_dispatcher.enqueue(handler)
+            channel.write_and_flush(message)
+          end
+
+          def prepare_to_close_channel(channel)
+            message_dispatcher = Connection::ChannelAttributes.message_dispatcher(channel)
+
+            message = Request::GoodbyeMessage::GOODBYE
+            message_dispatcher.enqueue(Handlers::NoOpResponseHandler::INSTANCE)
+            channel.write_and_flush(message, channel.void_promise)
+
+            message_dispatcher.prepare_to_close_channel
+          end
+
+          def begin_transaction(connection, bookmark, config)
+            verify_database_name_before_transaction(connection.database_name)
+            begin_message = Request::BeginMessage.new(bookmark, config, connection.database_name, connection.mode, connection.impersonated_user)
+            connection.write_and_flush(begin_message, Handlers::BeginTxResponseHandler.new)
+          end
+
+          def commit_transaction(connection)
+            Util::ResultHolder.new.tap do |result_holder|
+              connection.write_and_flush(Request::CommitMessage::COMMIT, Handlers::CommitTxResponseHandler.new(result_holder))
+            end
+          end
+
+          def rollback_transaction(connection)
+            Util::ResultHolder.new.tap do |result_holder|
+              connection.write_and_flush(Request::RollbackMessage::ROLLBACK, Handlers::RollbackTxResponseHandler.new(result_holder))
+            end
+          end
+
+          def run_in_auto_commit_transaction(connection, query, bookmark_holder, config, fetch_size)
+            verify_database_name_before_transaction(connection.database_name)
+
+            run_message = Request::RunWithMetadataMessage.auto_commit_tx_run_message(query, config, connection.database_name, connection.mode, bookmark_holder.bookmark, connection.impersonated_user)
+
+            build_result_cursor_factory(connection, query, bookmark_holder, nil, run_message, fetch_size)
+          end
+
+          def run_in_unmanaged_transaction(connection, query, tx, fetch_size)
+            run_message = Request::RunWithMetadataMessage.unmanaged_tx_run_message(query)
+            build_result_cursor_factory(connection, query, BookmarkHolder::NO_OP, tx, run_message, fetch_size)
+          end
+
+          def build_result_cursor_factory(connection, query, bookmark_holder, tx, run_message, ignored)
+            run_handler = Handlers::RunResponseHandler.new(METADATA_EXTRACTOR, connection, tx)
+            pull_handler = Handlers::PullHandlers.new_bolt_v3_pull_all_handler(query, run_handler, connection, bookmark_holder, tx)
+
+            Cursor::AsyncResultCursorOnlyFactory.new(connection, run_message, run_handler, pull_handler)
+          end
+
+          def verify_database_name_before_transaction(database_name)
+            Request::MultiDatabaseUtil.assert_empty_database_name(database_name, VERSION)
+          end
+
+          def version
+            self.class::VERSION
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v3/message_format_v3.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V3
+        class MessageFormatV3
+          def new_writer(output)
+            MessageWriterV3.new(output)
+          end
+
+          def new_reader(input)
+            Common::CommonMessageReader.new(input)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v3/message_writer_v3.rb

@@ -0,0 +1,27 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V3
+        class MessageWriterV3 < AbstractMessageWriter
+          COMMON_ENCODERS = {
+            Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder,
+            Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder,
+            Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder,
+            Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder,
+            Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder,
+            Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder,
+            Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder,
+          }
+          private
+
+          def build_encoders
+            COMMON_ENCODERS.merge(
+              Request::DiscardAllMessage::SIGNATURE => Encode::DiscardAllMessageEncoder,
+              Request::PullAllMessage::SIGNATURE => Encode::PullAllMessageEncoder,
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v4/bolt_protocol_v4.rb

@@ -0,0 +1,29 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V4
+        class BoltProtocolV4 < V3::BoltProtocolV3
+          VERSION = BoltProtocolVersion.new(4,0)
+          INSTANCE = new
+
+          def create_message_format
+            MessageFormatV4.new
+          end
+
+          def build_result_cursor_factory(connection, query, bookmark_holder, tx, run_message, fetch_size)
+            run_handler = Handlers::RunResponseHandler.new(V3::BoltProtocolV3::METADATA_EXTRACTOR, connection, tx)
+
+            pull_all_handler = Handlers::PullHandlers.new_bolt_v4_auto_pull_handler(query, run_handler, connection, bookmark_holder, tx, fetch_size)
+            pull_handler = Handlers::PullHandlers.new_bolt_v4_basic_pull_handler(query, run_handler, connection, bookmark_holder, tx)
+
+            Cursor::ResultCursorFactoryImpl.new(connection, run_message, run_handler, pull_handler, pull_all_handler)
+          end
+
+          def verify_database_name_before_transaction(_database_name)
+            # Bolt V4.1 accepts database name
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v4/message_format_v4.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V4
+        class MessageFormatV4
+          def new_writer(output)
+            MessageWriterV4.new(output)
+          end
+
+          def new_reader(input)
+            Common::CommonMessageReader.new(input)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v4/message_writer_v4.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V4
+        class MessageWriterV4 < V3::MessageWriterV3
+          private
+
+          def build_encoders
+            COMMON_ENCODERS.merge(
+              Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder,
+              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v41/bolt_protocol_v41.rb

@@ -0,0 +1,25 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V41
+        class BoltProtocolV41 < V4::BoltProtocolV4
+          VERSION = BoltProtocolVersion.new(4, 1)
+          INSTANCE = new
+
+          def create_message_format
+            V4::MessageFormatV4.new
+          end
+
+          def build_result_cursor_factory(connection, query, bookmark_holder, tx, run_message, fetch_size)
+            run_handler = Handlers::RunResponseHandler.new(V3::BoltProtocolV3::METADATA_EXTRACTOR, connection, tx)
+
+            pull_all_handler = Handlers::PullHandlers.new_bolt_v4_auto_pull_handler(query, run_handler, connection, bookmark_holder, tx, fetch_size)
+            pull_handler = Handlers::PullHandlers.new_bolt_v4_basic_pull_handler(query, run_handler, connection, bookmark_holder, tx)
+
+            Cursor::ResultCursorFactoryImpl.new(connection, run_message, run_handler, pull_handler, pull_all_handler)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v42/bolt_protocol_v42.rb

@@ -0,0 +1,13 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V42
+        # Bolt V4.2 is identical to V4.1
+        class BoltProtocolV42 < V41::BoltProtocolV41
+          VERSION = BoltProtocolVersion.new(4,2)
+          INSTANCE = new
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v43/bolt_protocol_v43.rb

@@ -0,0 +1,19 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V43
+        # Definition of the Bolt Protocol 4.3
+
+        # The version 4.3 use most of the 4.2 behaviours, but it extends it with new messages such as ROUTE
+        class BoltProtocolV43 < V42::BoltProtocolV42
+          VERSION = BoltProtocolVersion.new(4,3)
+          INSTANCE = new
+
+          def create_message_format
+            MessageFormatV43.new
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v43/message_format_v43.rb

@@ -0,0 +1,18 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V43
+        # Bolt message format v4.3
+        class MessageFormatV43
+          def new_writer(output)
+            MessageWriterV43.new(output)
+          end
+
+          def new_reader(input)
+            Common::CommonMessageReader.new(input)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v43/message_writer_v43.rb

@@ -0,0 +1,20 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V43
+
+        # Bolt message writer v4.3
+        # This version is able to encode all the versions existing on v4.2, but it encodes
+
+        # new messages such as ROUTE
+        class MessageWriterV43 < V4::MessageWriterV4
+          private
+
+          def build_encoders
+            super.merge(Request::RouteMessage::SIGNATURE => Encode::RouteMessageEncoder)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v44/bolt_protocol_v44.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V44
+        # Definition of the Bolt Protocol 4.4
+        class BoltProtocolV44 < V43::BoltProtocolV43
+          VERSION = BoltProtocolVersion.new(4,4)
+          INSTANCE = new
+
+          def create_message_format
+            MessageFormatV44.new
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v44/message_format_v44.rb

@@ -0,0 +1,18 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V44
+        # Bolt message format v4.4
+        class MessageFormatV44
+          def new_writer(output)
+            MessageWriterV44.new(output)
+          end
+
+          def new_reader(input)
+            CommonMessageReader.new(input)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v44/message_writer_v44.rb

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V44
+        class MessageWriterV44 < V4::MessageWriterV4
+          private
+
+          def build_encoders
+            super.merge(Request::RouteMessage::SIGNATURE => Encode::RouteV44MessageEncoder)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/metrics/connection_pool_metrics_listener.rb

@@ -0,0 +1,34 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      module ConnectionPoolMetricsListener
+        DEV_NULL_POOL_METRICS_LISTENER =
+          Class.new do
+            def before_creating(_listener_event) end
+
+            def after_created(_listener_event) end
+
+            def after_failed_to_create
+            end
+
+            def after_closed
+            end
+
+            def before_acquiring_or_creating(_acquire_event = nil) end
+
+            def after_acquiring_or_creating
+            end
+
+            def after_acquired_or_created(_acquire_event) end
+
+            def after_timed_out_to_acquire_or_create
+            end
+
+            def acquired(_in_use_event) end
+
+            def released(_in_use_event) end
+          end.new
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/metrics/internal_abstract_metrics.rb

@@ -0,0 +1,46 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      class InternalAbstractMetrics
+        DEV_NULL_METRICS =
+          Class.new do
+            def before_creating(_pool_id, _creating_event) end
+
+            def after_created(_pool_id, _creating_event) end
+
+            def after_failed_to_create(_pool_id) end
+
+            def after_closed(_pool_id) end
+
+            def before_acquiring_or_creating(_pool_id, _acquire_event) end
+
+            def after_acquiring_or_creating(_pool_id) end
+
+            def after_acquired_or_created(_pool_id, _acquire_event) end
+
+            def after_timed_out_to_acquire_or_create(_pool_id) end
+
+            def after_connection_created(_pool_id, _in_use_event) end
+
+            def after_connection_released(_pool_id, _in_use_event) end
+
+            def create_listener_event
+              ListenerEvent::DEV_NULL_LISTENER_EVENT
+            end
+
+            def put_pool_metrics(_id, _address, _connection_pool) end
+
+            def remove_pool_metrics(_pool_id) end
+
+            def connection_pool_metrics
+              Set.new
+            end
+
+            def to_s
+              'Driver metrics not available while driver metrics is not enabled.'
+            end
+          end.new
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/metrics/internal_connection_pool_metrics.rb

@@ -0,0 +1,105 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      class InternalConnectionPoolMetrics
+        attr_reader :id, :address, :pool
+
+        def initialize(pool_id, address, pool)
+          Internal::Validotor.require_non_nil!(address)
+          Internal::Validotor.require_non_nil!(pool)
+
+          @id = pool_id
+          @address = address
+          @pool = pool
+
+          @closed = Concurrent::AtomicFixnum.new
+
+          # creating = created + failedToCreate
+          @creating = Concurrent::AtomicFixnum.new
+          @created = Concurrent::AtomicFixnum.new
+          @failed_to_create = Concurrent::AtomicFixnum.new
+
+          # acquiring = acquired + timedOutToAcquire + failedToAcquireDueToOtherFailures (which we do not keep track)
+          @acquiring = Concurrent::AtomicFixnum.new
+          @acquired = Concurrent::AtomicFixnum.new
+          @timed_out_to_acquire = Concurrent::AtomicFixnum.new
+
+          @total_acquisition_time = Concurrent::AtomicFixnum.new
+          @total_connection_time = Concurrent::AtomicFixnum.new
+          @total_in_use_time = Concurrent::AtomicFixnum.new
+
+          @total_in_use_count = Concurrent::AtomicFixnum.new
+        end
+
+        def before_creating(conn_event)
+          @creating.increment
+          conn_event.start
+        end
+
+        def after_failed_to_create
+          @failed_to_create.increment
+          @creating.decrement_and_get
+        end
+
+        def after_created(conn_event)
+          @created.increment
+          @creating.decrement
+          elapsed = conn_event.elapsed
+
+          @total_connection_time.increment(elapsed)
+        end
+
+        def after_closed
+          @closed.increment
+        end
+
+        def before_acquiring_or_creating(acquire_event)
+          acquire_event.start
+          @acquiring.increment
+        end
+
+        def after_acquiring_or_creating
+          @acquiring.decrement
+        end
+
+        def after_acquired_or_created(acquire_event)
+          @acquired.increment
+          elapsed = acquire_event.elapsed
+          @total_acquisition_time.increment(elapsed)
+        end
+
+        def after_timed_out_to_acquire_or_create
+          @timed_out_to_acquire.increment
+        end
+
+        def acquired(in_use_event)
+          in_use_event.start
+        end
+
+        def released(in_use_event)
+          @total_in_use_count.increment
+          elapsed = in_use_event.elapsed
+
+          @total_in_use_time.increment(elapsed)
+        end
+
+        def in_use
+          @pool.in_use_connections(@address)
+        end
+
+        def idle
+          @pool.idle_connections(@address)
+        end
+
+        %i[creating created failed_to_create timed_out_to_acquire total_acquisition_time :total_connection_time
+        total_in_use_time total_in_use_count closed acquiring acquired].each do |method|
+          define_method(method) { instance_variable_get(method).value }
+        end
+
+        def to_s
+          "#{@id}[created=#{@created}, closed=#{@closed}, creating=#{@creating}, failed_to_create=#{@failed_to_create}, acquiring=#{@acquiring}, acquired=#{@acquired}, timed_out_to_acquire=#{@timed_out_to_acquire}, in_use=#{@in_use}, idle=#{@idle}, total_acquisition_time=#{@total_acquisition_time}, total_connection_time=#{@total_connection_time}, total_in_use_time=#{@total_in_use_time}, total_in_use_count=#{@totalInUseCount}]"
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/metrics/internal_metrics.rb

@@ -0,0 +1,82 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      class InternalMetrics
+        def initialize(logger)
+          @connection_pool_metrics = Concurrent::Map.new
+          @log = logger
+        end
+
+        def put_pool_metrics(pool_id, server_address, pool)
+          @connection_pool_metrics[pool_id] = InternalConnectionPoolMetrics.new(pool_id, server_address, pool)
+        end
+
+        def remove_pool_metrics(id)
+          @connection_pool_metrics.delete(id)
+        end
+
+        def before_creating(pool_id, creating_event)
+          pool_metrics(pool_id).before_creating(creating_event)
+        end
+
+        def after_created(pool_id, creating_event)
+          pool_metrics(pool_id).after_created(creating_event)
+        end
+
+        def after_failed_to_create(pool_id)
+          pool_metrics(pool_id).after_failed_to_create
+        end
+
+        def after_closed(pool_id)
+          pool_metrics(pool_id).after_closed
+        end
+
+        def before_acquiring_or_creating(pool_id, acquire_event)
+          pool_metrics(pool_id).before_acquiring_or_creating(acquire_event)
+        end
+
+        def after_acquiring_or_creating(pool_id)
+          pool_metrics(pool_id).after_acquiring_or_creating
+        end
+
+        def after_acquired_or_created(pool_id, acquire_event)
+          pool_metrics(pool_id).after_acquired_or_created(acquire_event)
+        end
+
+        def after_connection_created(pool_id, in_use_event)
+          pool_metrics(pool_id).acquired(in_use_event)
+        end
+
+        def after_connection_released(pool_id, in_use_event)
+          pool_metrics(pool_id).released(in_use_event)
+        end
+
+        def after_timed_out_to_acquire_or_create(pool_id)
+          pool_metrics(pool_id).after_timed_out_to_acquire_or_create
+        end
+
+        def create_listener_event
+          TimeRecorderListenerEvent.new
+        end
+
+        def connection_pool_metrics
+          @connection_pool_metrics.values.freeze
+        end
+
+        def to_s
+          "PoolMetrics=#{@connection_pool_metrics.each_pair.to_h}"
+        end
+
+        private
+
+        def pool_metrics(pool_id)
+          @connection_pool_metrics[pool_id] ||
+            begin
+              @log.warn("Failed to find pool metrics with id `#{pool_id}` in #{@connection_pool_metrics.each_pair.to_h}.")
+              ConnectionPoolMetricsListener::DEV_NULL_POOL_METRICS_LISTENER
+            end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/metrics/internal_metrics_provider.rb

@@ -0,0 +1,18 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      class InternalMetricsProvider
+        attr_reader :metrics
+        alias metrics_listener metrics
+
+        def initialize(logger)
+          @metrics = InternalMetrics.new(logger)
+        end
+
+        def metrics_enabled?
+          true
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/metrics/listener_event.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      module ListenerEvent
+        DEV_NULL_LISTENER_EVENT =
+          Class.new do
+            def start
+            end
+
+            def elapsed
+              0
+            end
+          end.new
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/metrics/metrics_provider.rb

@@ -0,0 +1,24 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      module MetricsProvider
+        METRICS_DISABLED_PROVIDER =
+          Class.new do
+            def metrics
+              # To outside users, we forbidden their access to the metrics API
+              raise Exceptions::ClientException, "Driver metrics not enabled. To access driver metrics, you need to enabled driver metrics in the driver's configuration."
+            end
+
+            def metrics_listener
+              # Internally we can still register callbacks to this empty metrics listener.
+              InternalAbstractMetrics::DEV_NULL_METRICS
+            end
+
+            def metrics_enabled?
+              false
+            end
+          end.new
+      end
+    end
+  end
+end