evt-message_store-postgres 2.4.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7898e559251e6013c71e09ad745cacecca46680f54f279d06eb7e4801d5f4fdc
+  data.tar.gz: 251012903cf9814e62eac3db90eee0f9d47467759017d53f81238dac33b0ba32
+SHA512:
+  metadata.gz: abb2182486ece01a11d7b15866275f4f7872419cb7e966cf9b5e850f717286efb10342466d3ce873072f7f622c0017a2a7bcba41d89495562fad336885fb0156
+  data.tar.gz: 4e7dd8ca3ff0fb4d924bf3fd552f7e00ae14b87d06703ea1a44cdd2f2e98a490d9439f5fa0274cca0a6995e1c79e7be896a57d9c4063b11cffa9b512b2550a46

data/lib/message_store/postgres.rb

@@ -0,0 +1,24 @@
+require 'pg'
+
+require 'message_store'
+
+require 'log'
+require 'telemetry'
+require 'settings'
+
+require 'message_store/postgres/log'
+
+require 'message_store/postgres/settings'
+require 'message_store/postgres/session'
+
+require 'message_store/postgres/put'
+require 'message_store/postgres/write'
+
+require 'message_store/postgres/get'
+require 'message_store/postgres/get/condition'
+require 'message_store/postgres/get/stream'
+require 'message_store/postgres/get/stream/last'
+require 'message_store/postgres/get/category'
+require 'message_store/postgres/get/category/correlation'
+require 'message_store/postgres/get/category/consumer_group'
+require 'message_store/postgres/read'

data/lib/message_store/postgres/controls.rb

@@ -0,0 +1,7 @@
+require 'message_store/controls'
+
+require 'message_store/postgres/controls/position'
+require 'message_store/postgres/controls/category'
+require 'message_store/postgres/controls/stream_name'
+require 'message_store/postgres/controls/message_data'
+require 'message_store/postgres/controls/put'

data/lib/message_store/postgres/controls/category.rb

@@ -0,0 +1,7 @@
+module MessageStore
+  module Postgres
+    module Controls
+      Category = MessageStore::Controls::Category
+    end
+  end
+end

data/lib/message_store/postgres/controls/message_data.rb

@@ -0,0 +1,31 @@
+module MessageStore
+  module Postgres
+    module Controls
+      MessageData = MessageStore::Controls::MessageData
+
+      module MessageData
+        module Write
+          module List
+            Entry = Struct.new(:stream_name, :category, :message_data)
+
+            def self.get(instances: nil, stream_name: nil, category: nil)
+              instances ||= 1
+
+              list = []
+              instances.times do
+                instance_stream_name = stream_name || StreamName.example(category: category)
+                instance_category = MessageStore::StreamName.get_category(instance_stream_name)
+
+                write_message = Controls::MessageData::Write.example
+
+                list << Entry.new(instance_stream_name, instance_category, write_message)
+              end
+
+              list
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/controls/position.rb

@@ -0,0 +1,15 @@
+module MessageStore
+  module Postgres
+    module Controls
+      module Position
+        def self.example
+          1
+        end
+
+        def self.max
+          (2 ** 63) - 1
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/controls/put.rb

@@ -0,0 +1,28 @@
+module MessageStore
+  module Postgres
+    module Controls
+      module Put
+        def self.call(instances: nil, stream_name: nil, message_data: nil, message: nil, category: nil)
+          instances ||= 1
+          stream_name ||= StreamName.example(category: category)
+          message_data ||= message
+
+          message_specified = !message_data.nil?
+
+          message_data ||= MessageData::Write.example
+
+          position = nil
+          instances.times do
+            position = MessageStore::Postgres::Put.(message_data, stream_name)
+
+            unless message_specified
+              message_data.id = MessageData::Write.id
+            end
+          end
+
+          [stream_name, position]
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/controls/stream_name.rb

@@ -0,0 +1,7 @@
+module MessageStore
+  module Postgres
+    module Controls
+      StreamName = MessageStore::Controls::StreamName
+    end
+  end
+end

data/lib/message_store/postgres/get.rb

@@ -0,0 +1,165 @@
+module MessageStore
+  module Postgres
+    module Get
+      def self.included(cls)
+        cls.class_exec do
+          include MessageStore::Get
+
+          prepend Call
+          prepend BatchSize
+
+          dependency :session, Session
+
+          abstract :stream_name
+          abstract :sql_command
+          abstract :parameters
+          abstract :parameter_values
+          abstract :last_position
+          abstract :log_text
+
+          virtual :specialize_error
+          virtual :assure
+        end
+      end
+
+      module BatchSize
+        def batch_size
+          @batch_size ||= Defaults.batch_size
+        end
+      end
+
+      def self.build(stream_name, **args)
+        cls = specialization(stream_name)
+        cls.build(stream_name, **args)
+      end
+
+      def self.configure(receiver, stream_name, **args)
+        attr_name = args.delete(:attr_name)
+        attr_name ||= :get
+
+        instance = build(stream_name, **args)
+        receiver.public_send("#{attr_name}=", instance)
+      end
+
+      def configure(session: nil)
+        Session.configure(self, session: session)
+      end
+
+      def self.call(stream_name, **args)
+        position = args.delete(:position)
+        instance = build(stream_name, **args)
+        instance.(position)
+      end
+
+      module Call
+        def call(position=nil, stream_name: nil)
+          position ||= self.class::Defaults.position
+
+          stream_name ||= self.stream_name
+
+          assure
+
+          logger.trace(tag: :get) { "Getting message data (#{log_text(stream_name, position)})" }
+
+          result = get_result(stream_name, position)
+
+          message_data = convert(result)
+
+          logger.info(tag: :get) { "Finished getting message data (Count: #{message_data.length}, #{log_text(stream_name, position)})" }
+          logger.info(tags: [:data, :message_data]) { message_data.pretty_inspect }
+
+          message_data
+        end
+      end
+
+      def get_result(stream_name, position)
+        logger.trace(tag: :get) { "Getting result (#{log_text(stream_name, position)})" }
+
+        parameter_values = parameter_values(stream_name, position)
+
+        begin
+          result = session.execute(sql_command, parameter_values)
+        rescue PG::RaiseException => e
+          raise_error(e)
+        end
+
+        logger.debug(tag: :get) { "Finished getting result (Count: #{result.ntuples}, #{log_text(stream_name, position)})" }
+
+        result
+      end
+
+      def convert(result)
+        logger.trace(tag: :get) { "Converting result to message data (Result Count: #{result.ntuples})" }
+
+        message_data = result.map do |record|
+          Get.message_data(record)
+        end
+
+        logger.debug(tag: :get) { "Converted result to message data (Message Data Count: #{message_data.length})" }
+
+        message_data
+      end
+
+      def self.message_data(record)
+        record['data'] = Get::Deserialize.data(record['data'])
+        record['metadata'] = Get::Deserialize.metadata(record['metadata'])
+        record['time'] = Get::Time.utc_coerced(record['time'])
+
+        MessageData::Read.build(record)
+      end
+
+      def raise_error(pg_error)
+        error_message = Get.error_message(pg_error)
+
+        error = Condition.error(error_message)
+
+        if error.nil?
+          error = specialize_error(error_message)
+        end
+
+        if not error.nil?
+          logger.error { error_message }
+          raise error
+        end
+
+        raise pg_error
+      end
+
+      def self.error_message(pg_error)
+        pg_error.message.gsub('ERROR:', '').strip
+      end
+
+      def self.specialization(stream_name)
+        if StreamName.category?(stream_name)
+          Category
+        else
+          Stream
+        end
+      end
+
+      module Deserialize
+        def self.data(serialized_data)
+          return nil if serialized_data.nil?
+          Transform::Read.(serialized_data, :json, MessageData::Hash)
+        end
+
+        def self.metadata(serialized_metadata)
+          return nil if serialized_metadata.nil?
+          Transform::Read.(serialized_metadata, :json, MessageData::Hash)
+        end
+      end
+
+      module Time
+        def self.utc_coerced(local_time)
+          Clock::UTC.coerce(local_time)
+        end
+      end
+
+      module Defaults
+        def self.batch_size
+          1000
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/category.rb

@@ -0,0 +1,81 @@
+module MessageStore
+  module Postgres
+    module Get
+      class Category
+        Error = Class.new(RuntimeError)
+
+        include Get
+
+        initializer :category, na(:batch_size), :correlation, :consumer_group_member, :consumer_group_size, :condition
+        alias :stream_name :category
+
+        def self.call(category, position: nil, batch_size: nil, correlation: nil, consumer_group_member: nil, consumer_group_size: nil, condition: nil, session: nil)
+          instance = build(category, batch_size: batch_size, correlation: correlation, consumer_group_member: consumer_group_member, consumer_group_size: consumer_group_size, condition: condition, session: session)
+          instance.(position)
+        end
+
+        def self.build(category, batch_size: nil, correlation: nil, consumer_group_member: nil, consumer_group_size: nil, condition: nil, session: nil)
+          instance = new(category, batch_size, correlation, consumer_group_member, consumer_group_size, condition)
+          instance.configure(session: session)
+          instance
+        end
+
+        def self.configure(receiver, category, attr_name: nil, batch_size: nil, correlation: nil, consumer_group_member: nil, consumer_group_size: nil, condition: nil, session: nil)
+          attr_name ||= :get
+          instance = build(category, batch_size: batch_size, correlation: correlation, consumer_group_member: consumer_group_member, consumer_group_size: consumer_group_size, condition: condition, session: session)
+          receiver.public_send("#{attr_name}=", instance)
+        end
+
+        def sql_command
+          "SELECT * FROM get_category_messages(#{parameters});"
+        end
+
+        def parameters
+          '$1::varchar, $2::bigint, $3::bigint, $4::varchar, $5::bigint, $6::bigint, $7::varchar'
+        end
+
+        def parameter_values(category, position)
+          [
+            category,
+            position,
+            batch_size,
+            correlation,
+            consumer_group_member,
+            consumer_group_size,
+            condition
+          ]
+        end
+
+        def last_position(batch)
+          batch.last.global_position
+        end
+
+        def specialize_error(error_message)
+          error = Correlation.error(error_message)
+
+          if error.nil?
+            error = ConsumerGroup.error(error_message)
+          end
+
+          error
+        end
+
+        def log_text(category, position)
+          "Category: #{category}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect}, Correlation: #{correlation.inspect}, Consumer Group Member: #{consumer_group_member.inspect}, Consumer Group Size: #{consumer_group_size.inspect}, Condition: #{condition.inspect})"
+        end
+
+        def assure
+          if not MessageStore::StreamName.category?(category)
+            raise Error, "Must be a category (Stream Name: #{category})"
+          end
+        end
+
+        module Defaults
+          def self.position
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/category/consumer_group.rb

@@ -0,0 +1,20 @@
+module MessageStore
+  module Postgres
+    module Get
+      class Category
+        module ConsumerGroup
+          Error = Class.new(RuntimeError)
+
+          def self.error(error_message)
+            if error_message.start_with?('Consumer group size must not be less than 1') ||
+                error_message.start_with?('Consumer group member must be less than the group size') ||
+                error_message.start_with?('Consumer group member must not be less than 0') ||
+                error_message.start_with?('Consumer group member and size must be specified')
+              Error.new(error_message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/category/correlation.rb

@@ -0,0 +1,17 @@
+module MessageStore
+  module Postgres
+    module Get
+      class Category
+        module Correlation
+          Error = Class.new(RuntimeError)
+
+          def self.error(error_message)
+            if error_message.start_with?('Correlation must be a category')
+              Error.new(error_message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/condition.rb

@@ -0,0 +1,15 @@
+module MessageStore
+  module Postgres
+    module Get
+      module Condition
+        Error = Class.new(RuntimeError)
+
+        def self.error(error_message)
+          if error_message.start_with?('Retrieval with SQL condition is not activated')
+            Get::Condition::Error.new(error_message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/stream.rb

@@ -0,0 +1,67 @@
+module MessageStore
+  module Postgres
+    module Get
+      class Stream
+        Error = Class.new(RuntimeError)
+
+        include Get
+
+        initializer :stream_name, na(:batch_size), :condition
+
+        def self.call(stream_name, position: nil, batch_size: nil, condition: nil, session: nil)
+          instance = build(stream_name, batch_size: batch_size, condition: condition, session: session)
+          instance.(position)
+        end
+
+        def self.build(stream_name, batch_size: nil, condition: nil, session: nil)
+          instance = new(stream_name, batch_size, condition)
+          instance.configure(session: session)
+          instance
+        end
+
+        def self.configure(receiver, stream_name, attr_name: nil, batch_size: nil, condition: nil, session: nil)
+          attr_name ||= :get
+          instance = build(stream_name, batch_size: batch_size, condition: condition, session: session)
+          receiver.public_send("#{attr_name}=", instance)
+        end
+
+        def sql_command
+          "SELECT * FROM get_stream_messages(#{parameters});"
+        end
+
+        def parameters
+          '$1::varchar, $2::bigint, $3::bigint, $4::varchar'
+        end
+
+        def parameter_values(stream_name, position)
+          [
+            stream_name,
+            position,
+            batch_size,
+            condition
+          ]
+        end
+
+        def last_position(batch)
+          batch.last.position
+        end
+
+        def log_text(stream_name, position)
+          "Stream Name: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect}, Condition: #{condition.inspect})"
+        end
+
+        def assure
+          if MessageStore::StreamName.category?(stream_name)
+            raise Error, "Must be a stream name (Category: #{stream_name})"
+          end
+        end
+
+        module Defaults
+          def self.position
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/stream/last.rb

@@ -0,0 +1,66 @@
+module MessageStore
+  module Postgres
+    module Get
+      class Stream
+        class Last
+          include MessageStore::Get::Stream::Last
+
+          dependency :session, Session
+
+          def configure(session: nil)
+            Session.configure(self, session: session)
+          end
+
+          def call(stream_name)
+            logger.trace(tag: :get) { "Getting last message data (Stream Name: #{stream_name})" }
+
+            result = get_result(stream_name)
+
+            return nil if result.nil?
+
+            message_data = convert(result[0])
+
+            logger.info(tag: :get) { "Finished getting message data (Stream Name: #{stream_name})" }
+            logger.info(tags: [:data, :message_data]) { message_data.pretty_inspect }
+
+            message_data
+          end
+
+          def get_result(stream_name)
+            logger.trace(tag: :get) { "Getting last record (Stream: #{stream_name})" }
+
+            sql_command = self.class.sql_command(stream_name)
+
+            parameter_values = [
+              stream_name
+            ]
+
+            result = session.execute(sql_command, parameter_values)
+
+            logger.debug(tag: :get) { "Finished getting result (Count: #{result.ntuples}, Stream: #{stream_name}" }
+
+            return nil if result.ntuples == 0
+
+            result
+          end
+
+          def self.sql_command(stream_name)
+            parameters = '$1::varchar'
+
+            "SELECT * FROM get_last_stream_message(#{parameters});"
+          end
+
+          def convert(record)
+            logger.trace(tag: :get) { "Converting record to message data" }
+
+            message_data = Get.message_data(record)
+
+            logger.debug(tag: :get) { "Converted record to message data" }
+
+            message_data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/log.rb

@@ -0,0 +1,9 @@
+module MessageStore
+  module Postgres
+    class Log < ::Log
+      def tag!(tags)
+        tags << :message_store
+      end
+    end
+  end
+end

data/lib/message_store/postgres/put.rb

@@ -0,0 +1,146 @@
+module MessageStore
+  module Postgres
+    class Put
+      include Dependency
+      include Log::Dependency
+
+      dependency :session, Session
+      dependency :identifier, Identifier::UUID::Random
+
+      def self.build(session: nil)
+        new.tap do |instance|
+          instance.configure(session: session)
+        end
+      end
+
+      def configure(session: nil)
+        Session.configure(self, session: session)
+        Identifier::UUID::Random.configure(self)
+      end
+
+      def self.configure(receiver, session: nil, attr_name: nil)
+        attr_name ||= :put
+        instance = build(session: session)
+        receiver.public_send "#{attr_name}=", instance
+      end
+
+      def self.call(write_message, stream_name, expected_version: nil, session: nil)
+        instance = build(session: session)
+        instance.(write_message, stream_name, expected_version: expected_version)
+      end
+
+      def call(write_message, stream_name, expected_version: nil)
+        logger.trace(tag: :put) { "Putting message data (Type: #{write_message.type}, Stream Name: #{stream_name}, Expected Version: #{expected_version.inspect})" }
+        logger.trace(tags: [:data, :message_data]) { write_message.pretty_inspect }
+
+        write_message.id ||= identifier.get
+
+        id, type, data, metadata = destructure_message(write_message)
+        expected_version = ExpectedVersion.canonize(expected_version)
+
+        insert_message(id, stream_name, type, data, metadata, expected_version).tap do |position|
+          logger.info(tag: :put) { "Put message data (Type: #{write_message.type}, Stream Name: #{stream_name}, Expected Version: #{expected_version.inspect}, ID: #{id.inspect}, Position: #{position})" }
+          logger.info(tags: [:data, :message_data]) { write_message.pretty_inspect }
+        end
+      end
+
+      def destructure_message(write_message)
+        id = write_message.id
+        type = write_message.type
+        data = write_message.data
+        metadata = write_message.metadata
+
+        logger.debug(tags: [:data, :message_data]) { "ID: #{id.pretty_inspect}" }
+        logger.debug(tags: [:data, :message_data]) { "Type: #{type.pretty_inspect}" }
+        logger.debug(tags: [:data, :message_data]) { "Data: #{data.pretty_inspect}" }
+        logger.debug(tags: [:data, :message_data]) { "Metadata: #{metadata.pretty_inspect}" }
+
+        return id, type, data, metadata
+      end
+
+      def insert_message(id, stream_name, type, data, metadata, expected_version)
+        transformed_data = transformed_data(data)
+        transformed_metadata = transformed_metadata(metadata)
+        records = execute_query(id, stream_name, type, transformed_data, transformed_metadata, expected_version)
+        position(records)
+      end
+
+      def execute_query(id, stream_name, type, transformed_data, transformed_metadata, expected_version)
+        logger.trace(tag: :put) { "Executing insert (Stream Name: #{stream_name}, Type: #{type}, Expected Version: #{expected_version.inspect}, ID: #{id.inspect})" }
+
+        params = [
+          id,
+          stream_name,
+          type,
+          transformed_data,
+          transformed_metadata,
+          expected_version
+        ]
+
+        begin
+          records = session.execute(self.class.statement, params)
+        rescue PG::RaiseException => e
+          raise_error e
+        end
+
+        logger.debug(tag: :put) { "Executed insert (Type: #{type}, Stream Name: #{stream_name}, Expected Version: #{expected_version.inspect}, ID: #{id.inspect})" }
+
+        records
+      end
+
+      def self.statement
+        @statement ||= "SELECT write_message($1::varchar, $2::varchar, $3::varchar, $4::jsonb, $5::jsonb, $6::bigint);"
+      end
+
+      def transformed_data(data)
+        transformed_data = nil
+
+        if data.is_a?(Hash) && data.empty?
+          data = nil
+        end
+
+        unless data.nil?
+          transformable_data = MessageData::Hash[data]
+          transformed_data = Transform::Write.(transformable_data, :json)
+        end
+
+        logger.debug(tags: [:data, :serialize]) { "Transformed Data: #{transformed_data.inspect}" }
+        transformed_data
+      end
+
+      def transformed_metadata(metadata)
+        transformed_metadata = nil
+
+        if metadata.is_a?(Hash) && metadata.empty?
+          metadata = nil
+        end
+
+        unless metadata.nil?
+          transformable_metadata = MessageData::Hash[metadata]
+          transformed_metadata = Transform::Write.(transformable_metadata, :json)
+        end
+
+        logger.debug(tags: [:data, :serialize]) { "Transformed Metadata: #{transformed_metadata.inspect}" }
+        transformed_metadata
+      end
+
+      def position(records)
+        position = nil
+        unless records[0].nil?
+          position = records[0].values[0]
+        end
+        position
+      end
+
+      def raise_error(pg_error)
+        error_message = pg_error.message
+        if error_message.include? 'Wrong expected version'
+          error_message.gsub!('ERROR:', '').strip!
+          logger.error { error_message }
+          raise ExpectedVersion::Error, error_message
+        end
+        raise pg_error
+      end
+    end
+  end
+end

data/lib/message_store/postgres/read.rb

@@ -0,0 +1,17 @@
+module MessageStore
+  module Postgres
+    class Read
+      include MessageStore::Read
+
+      def configure(session: nil, condition: nil)
+        Get.configure(self.iterator, self.stream_name, batch_size: batch_size, condition: condition, session: session)
+      end
+
+      module Defaults
+        def self.batch_size
+          Postgres::Get::Defaults.batch_size
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/session.rb

@@ -0,0 +1,148 @@
+module MessageStore
+  module Postgres
+    class Session
+      Error = Class.new(RuntimeError)
+
+      include Settings::Setting
+
+      include Log::Dependency
+
+      def self.settings
+        Settings.names
+      end
+
+      settings.each do |s|
+        setting s
+      end
+
+      attr_accessor :connection
+
+      def self.build(settings: nil)
+        new.tap do |instance|
+          settings ||= Settings.instance
+          settings.set(instance)
+        end
+      end
+
+      def self.configure(receiver, session: nil, settings: nil, attr_name: nil)
+        attr_name ||= :session
+
+        if session != nil && settings != nil
+          error_msg = "Session configured with both settings and session arguments. Use one or the other, but not both."
+          logger.error(tag: :session) { error_msg }
+          raise Error, error_msg
+        end
+
+        instance = session || build(settings: settings)
+        receiver.public_send "#{attr_name}=", instance
+        instance
+      end
+
+      def open
+        logger.trace(tag: :session) { "Connecting to database" }
+
+        if connected?
+          logger.debug(tag: :session) { "Already connected. A new connection will not be built." }
+          return connection
+        end
+
+        logger.debug(tag: :session) { "Not connected. A new connection will be built." }
+        connection = self.class.build_connection(self)
+        self.connection = connection
+
+        logger.debug(tag: :session) { "Connected to database" }
+
+        connection
+      end
+      alias :connect :open
+
+      def self.build_connection(instance)
+        settings = instance.settings
+        logger.trace(tag: :session) { "Building new connection to database (Settings: #{LogText.settings(settings).inspect})" }
+
+        connection = PG::Connection.open(settings)
+        connection.type_map_for_results = PG::BasicTypeMapForResults.new(connection)
+
+        logger.debug(tag: :session) { "Built new connection to database (Settings: #{LogText.settings(settings).inspect})" }
+
+        connection
+      end
+
+      def connected?
+        return false if connection.nil?
+
+        status = PG::CONNECTION_OK
+        begin
+          status = connection.status
+        rescue PG::ConnectionBad
+          status = nil
+        end
+
+        status == PG::CONNECTION_OK
+      end
+      alias :open? :connected?
+
+      def close
+        connection.close
+        connection = nil
+      end
+
+      def reset
+        connection.reset
+      end
+
+      def settings
+        settings = {}
+        self.class.settings.each do |s|
+          val = public_send(s)
+          settings[s] = val unless val.nil?
+        end
+        settings
+      end
+
+      def execute(sql_command, params=nil)
+        logger.trace(tag: :session) { "Executing SQL command" }
+        logger.trace(tag: :sql) { sql_command }
+        logger.trace(tag: :data) { params.pretty_inspect }
+
+        unless connected?
+          connect
+        end
+
+        if params.nil?
+          connection.exec(sql_command).tap do
+            logger.debug(tag: :session) { "Executed SQL command (no params)" }
+          end
+        else
+          connection.exec_params(sql_command, params).tap do
+            logger.debug(tag: :session) { "Executed SQL command with params" }
+          end
+        end
+      end
+
+      def transaction(&blk)
+        unless connected?
+          connect
+        end
+
+        connection.transaction(&blk)
+      end
+
+      def self.logger
+        @logger ||= Log.get self
+      end
+
+      module LogText
+        def self.settings(settings)
+          s = settings.dup
+
+          if s.has_key?(:password)
+            s[:password] = '*' * 8
+          end
+
+          s
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/settings.rb

@@ -0,0 +1,36 @@
+module MessageStore
+  module Postgres
+    class Settings < ::Settings
+      def self.instance
+        @instance ||= build
+      end
+
+      def self.data_source
+        Defaults.data_source
+      end
+
+      def self.names
+        [
+          :dbname,
+          :host,
+          :hostaddr,
+          :port,
+          :user,
+          :password,
+          :connect_timeout,
+          :options,
+          :sslmode,
+          :krbsrvname,
+          :gsslib,
+          :service
+        ]
+      end
+
+      class Defaults
+        def self.data_source
+          ENV['MESSAGE_STORE_SETTINGS_PATH'] || 'settings/message_store_postgres.json'
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/write.rb

@@ -0,0 +1,52 @@
+module MessageStore
+  module Postgres
+    class Write
+      include MessageStore::Write
+
+      dependency :put
+
+      def configure(session: nil)
+        Put.configure(self, session: session)
+      end
+
+      def write(batch, stream_name, expected_version: nil)
+        logger.trace(tag: :write) do
+          message_types = batch.map {|message_data| message_data.type }.uniq.join(', ')
+          "Writing batch (Stream Name: #{stream_name}, Types: #{message_types}, Number of Messages: #{batch.length}, Expected Version: #{expected_version.inspect})"
+        end
+
+        unless expected_version.nil?
+          expected_version = ExpectedVersion.canonize(expected_version)
+        end
+
+        last_position = nil
+        put.session.transaction do
+          batch.each do |message_data|
+            last_position = write_message_data(message_data, stream_name, expected_version: expected_version)
+
+            unless expected_version.nil?
+              expected_version += 1
+            end
+          end
+        end
+
+        logger.debug(tag: :write) do
+          message_types = batch.map {|message_data| message_data.type }.uniq.join(', ')
+          "Wrote batch (Stream Name: #{stream_name}, Types: #{message_types}, Number of Messages: #{batch.length}, Expected Version: #{expected_version.inspect})"
+        end
+
+        last_position
+      end
+
+      def write_message_data(message_data, stream_name, expected_version: nil)
+        logger.trace(tag: :write) { "Writing message data (Stream Name: #{stream_name}, Type: #{message_data.type}, Expected Version: #{expected_version.inspect})" }
+        logger.trace(tags: [:data, :message_data]) { message_data.pretty_inspect }
+
+        put.(message_data, stream_name, expected_version: expected_version).tap do
+          logger.debug(tag: :write) { "Wrote message data (Stream Name: #{stream_name}, Type: #{message_data.type}, Expected Version: #{expected_version.inspect})" }
+          logger.debug(tags: [:data, :message_data]) { message_data.pretty_inspect }
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: evt-message_store-postgres
+version: !ruby/object:Gem::Version
+  version: 2.4.0.5
+platform: ruby
+authors:
+- The Eventide Project
+autorequire: 
+bindir: scripts
+cert_chain: []
+date: 2020-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: evt-message_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: evt-log
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: evt-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: message-db
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test_bench
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: evt-diagnostics-sample
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ntl-actor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " "
+email: opensource@eventide-project.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/message_store/postgres.rb
+- lib/message_store/postgres/controls.rb
+- lib/message_store/postgres/controls/category.rb
+- lib/message_store/postgres/controls/message_data.rb
+- lib/message_store/postgres/controls/position.rb
+- lib/message_store/postgres/controls/put.rb
+- lib/message_store/postgres/controls/stream_name.rb
+- lib/message_store/postgres/get.rb
+- lib/message_store/postgres/get/category.rb
+- lib/message_store/postgres/get/category/consumer_group.rb
+- lib/message_store/postgres/get/category/correlation.rb
+- lib/message_store/postgres/get/condition.rb
+- lib/message_store/postgres/get/stream.rb
+- lib/message_store/postgres/get/stream/last.rb
+- lib/message_store/postgres/log.rb
+- lib/message_store/postgres/put.rb
+- lib/message_store/postgres/read.rb
+- lib/message_store/postgres/session.rb
+- lib/message_store/postgres/settings.rb
+- lib/message_store/postgres/write.rb
+homepage: https://github.com/eventide-project/message-store-postgres
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Message store implementation for PostgreSQL
+test_files: []